§
    ™Štj› ã                  ó–  — d dl mZ d dlZd dlZd dlZd dlZd dlZd dlZd dlm	Z	m
Z
 d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlZd d	lmZ d d
lmZmZmZmZ d dlmZmZmZm Z  d dl!m"Z" d dl#m$Z$ d dl%m&Z& d dl'm(Z( d dl)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ d dl0m1Z1m2Z2 d dl3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z= d dl>m?Z? d dl@mAZAmBZB d dlCmDZD d dlEmFZFmGZG d dlHmIZI d dlJmKZKmLZLmMZMmNZNmOZOmPZP d dlQmRZRmSZSmTZT d dlUmVZVmWZWmXZXmYZY d dlZm[Z[  eX¦   «         rd dl\m]Z]m^Z^m_Z_m`Z`maZa  ejb        ec¦  «        Zd	 d dl%meZe n# ef$ r dZeY nw xY w G d„ dee	¦  «        ZgdS ) é    )ÚannotationsN)ÚABCÚabstractmethod)ÚOrderedDict)ÚCallable)Únullcontext)Úpartial)ÚAny)Únn)ÚBatchSamplerÚConcatDatasetÚ
DataLoaderÚRandomSampler)ÚEvalPredictionÚPreTrainedTokenizerBaseÚTrainerÚTrainerCallback)ÚFeatureExtractionMixin)ÚBaseImageProcessor)ÚWandbCallback)ÚProcessorMixin)ÚOPTIMIZER_NAMEÚOPTIMIZER_NAME_BINÚSCALER_NAMEÚSCHEDULER_NAMEÚTRAINER_STATE_NAMEÚTRAINING_ARGS_NAME)ÚEvalLoopOutputÚHubStrategy)
ÚADAPTER_CONFIG_NAMEÚADAPTER_SAFE_WEIGHTS_NAMEÚADAPTER_WEIGHTS_NAMEÚCONFIG_NAMEÚGENERATION_CONFIG_NAMEÚSAFE_WEIGHTS_INDEX_NAMEÚSAFE_WEIGHTS_NAMEÚWEIGHTS_INDEX_NAMEÚWEIGHTS_NAMEÚis_peft_available)ÚBaseDataCollator)ÚBaseEvaluatorÚSequentialEvaluator©Ú	BaseModel)ÚBaseModelCardCallbackÚBaseModelCardData)ÚRouter)ÚDefaultBatchSamplerÚGroupByLabelBatchSamplerÚMultiDatasetDefaultBatchSamplerÚNoDuplicatesBatchSamplerÚProportionalBatchSamplerÚRoundRobinBatchSampler)ÚBaseTrainingArgumentsÚBatchSamplersÚMultiDatasetBatchSamplers)Údisable_loggingÚfullnameÚis_datasets_availableÚis_training_available)Údeprecated_kwargs)ÚDatasetÚDatasetDictÚIterableDatasetÚIterableDatasetDictÚValue)ÚTrackioCallbackc                  óü  ‡ — e Zd ZdZeZeZeZ	e
ZeZ ed¬¦  «        	 	 	 	 	 	 	 	 	 	 	 	 	 	 d‹dŒˆ fd"„¦   «         Z	 d�dŽd&„Zd�d)„Zd�d�ˆ fd*„Zd‘d,„Zd’d.„Zed“d/„¦   «         Z	 	 d”d•d6„Zd–d8„Zd�d—ˆ fd=„Zd˜d?„Z	 	 	 d™dšˆ fdF„Z	 	 	 d™d›ˆ fdM„ZdœdN„Zd�d�dS„Z	 	 	 dždŸd]„Z	 	 d d¡dc„Z d¢df„Z!d£dg„Z"	 d�d¤di„Z#d¥dk„Z$dd¦dm„Z%d§ˆ fdo„Z&d¨dq„Z'd©ds„Z(	 ddªdu„Z)d«dw„Z*	 d�d¬dy„Z+e,	 	 dd­d~„¦   «         Z-	 	 	 	 	 	 	 	 	 d®d¯dˆ„Z.	 d�d°ˆ fdŠ„Z/ˆ xZ0S )±ÚBaseTraineruz  
    BaseTrainer is a simple but feature-complete training and eval loop for PyTorch
    based on the ðŸ¤— Transformers :class:`~transformers.Trainer`.

    This trainer integrates support for various :class:`transformers.TrainerCallback` subclasses, such as:

    - :class:`~transformers.integrations.WandbCallback` to automatically log training metrics to W&B if `wandb` is installed
    - :class:`~transformers.integrations.TensorBoardCallback` to log training metrics to TensorBoard if `tensorboard` is accessible.
    - :class:`~transformers.integrations.CodeCarbonCallback` to track the carbon emissions of your model during training if `codecarbon` is installed.

        - Note: These carbon emissions will be included in your automatically generated model card.

    See the Transformers `Callbacks <https://huggingface.co/docs/transformers/main/en/main_classes/callback>`_
    documentation for more information on the integrated callbacks and how to write your own callbacks.

    Args:
        model (:class:`~sentence_transformers.base.model.BaseModel`, *optional*):
            The model to train, evaluate or use for predictions. If not provided, a `model_init` must be passed.
        args (:class:`~sentence_transformers.base.training_args.BaseTrainingArguments`, *optional*):
            The arguments to tweak for training. Will default to a basic instance of
            :class:`~sentence_transformers.base.training_args.BaseTrainingArguments` with the
            ``output_dir`` set to a directory named ``"tmp_trainer"`` in the current directory if not provided.
        train_dataset (Union[:class:`datasets.Dataset`, :class:`datasets.DatasetDict`, :class:`datasets.IterableDataset`, Dict[str, :class:`datasets.Dataset`]], *optional*):
            The dataset to use for training. Must have a format accepted by your loss function.
        eval_dataset (Union[:class:`datasets.Dataset`, :class:`datasets.DatasetDict`, :class:`datasets.IterableDataset`, Dict[str, :class:`datasets.Dataset`]], *optional*):
            The dataset to use for evaluation. Must have a format accepted by your loss function.
        loss (Optional[Union[:class:`torch.nn.Module`, Dict[str, :class:`torch.nn.Module`],            Callable[[:class:`~sentence_transformers.base.model.BaseModel`], :class:`torch.nn.Module`],            Dict[str, Callable[[:class:`~sentence_transformers.base.model.BaseModel`]]]], *optional*):
            The loss function to use for training. Can either be a loss class instance, a dictionary mapping
            dataset names to loss class instances, a function that returns a loss class instance given a model,
            or a dictionary mapping dataset names to functions that return a loss class instance given a model.
            In practice, the latter two are primarily used for hyper-parameter optimization.
        evaluator (Union[:class:`~sentence_transformers.base.evaluation.BaseEvaluator`,            List[:class:`~sentence_transformers.base.evaluation.BaseEvaluator`]], *optional*):
            The evaluator instance for useful evaluation metrics during training. You can use an ``evaluator`` with
            or without an ``eval_dataset``, and vice versa. Generally, the metrics that an ``evaluator`` returns
            are more useful than the loss value returned from the ``eval_dataset``. A list of evaluators will be
            wrapped in a :class:`~sentence_transformers.base.evaluation.SequentialEvaluator` to run them sequentially.
        callbacks (List of [:class:`transformers.TrainerCallback`], *optional*):
            A list of callbacks to customize the training loop. Will add those to the list of default callbacks
            detailed in :doc:`here <transformers:main_classes/callback>`.

            If you want to remove one of the default callbacks used, use the :meth:`~transformers.Trainer.remove_callback` method.
        optimizers (Tuple[:class:`torch.optim.Optimizer`, :class:`torch.optim.lr_scheduler.LambdaLR`], *optional*, defaults to ``(None, None)``):
            A tuple containing the optimizer and the scheduler to use. Will default to an instance of :class:`torch.optim.AdamW`
            on your model and a scheduler given by :func:`transformers.get_linear_schedule_with_warmup` controlled by `args`.

    Important attributes:

        - **model**: Always points to the :class:`~sentence_transformers.base.model.BaseModel` model to be trained.
        - **model_wrapped**: Always points to the most external model in case one or more other modules wrap the
          original model. This is the model that should be used for the forward pass. For example, under ``DeepSpeed``,
          the inner model is wrapped in ``DeepSpeed`` and then again in :class:`~torch.nn.parallel.DistributedDataParallel`. If the inner
          model hasn't been wrapped, then ``self.model_wrapped`` is the same as ``self.model``.
        - **is_model_parallel**: Whether or not a model has been switched to a model parallel mode (different from
          data parallelism, this means some of the model layers are split on different GPUs).
        - **place_model_on_device**: Whether or not to automatically place the model on the device - it will be set
          to ``False`` if model parallel or deepspeed is used, or if the default
          :attr:`~sentence_transformers.base.training_args.BaseTrainingArguments.place_model_on_device` is overridden to return ``False``.
        - **is_in_train**: Whether or not a model is currently running :meth:`~sentence_transformers.base.trainer.BaseTrainer.train` (e.g. when :meth:`~sentence_transformers.base.trainer.BaseTrainer.evaluate` is called while
          in :meth:`~sentence_transformers.base.trainer.BaseTrainer.train`)

    Úprocessing_class)Ú	tokenizerN©NNÚmodelúBaseModel | NoneÚargsúBaseTrainingArguments | NoneÚtrain_datasetúCDataset | DatasetDict | IterableDataset | dict[str, Dataset] | NoneÚeval_datasetÚlossú„nn.Module | dict[str, nn.Module] | Callable[[BaseModel], torch.nn.Module] | dict[str, Callable[[BaseModel], torch.nn.Module]] | NoneÚ	evaluatorú*BaseEvaluator | list[BaseEvaluator] | NoneÚdata_collatorúBaseDataCollator | Noneú]PreTrainedTokenizerBase | BaseImageProcessor | FeatureExtractionMixin | ProcessorMixin | NoneÚ
model_initúCallable[[], BaseModel] | NoneÚcompute_metricsú'Callable[[EvalPrediction], dict] | NoneÚ	callbacksúlist[TrainerCallback] | NoneÚ
optimizersú?tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]Úoptimizer_cls_and_kwargsú9tuple[type[torch.optim.Optimizer], dict[str, Any]] | NoneÚpreprocess_logits_for_metricsú;Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | NoneÚreturnÚNonec                ó*  •‡ ‡‡— t          ¦   «         st          d‰ j        j        › d�¦  «        ‚|€Dd}t                               d‰ j        j        › d|› d�¦  «         ‰                      |¬¦  «        }n:t          |‰ j        ¦  «        s%t          dt          ‰ j        ¦  «        › d	�¦  «        ‚‰€;|	�|	‰ _
        ‰                      ¦   «         ŠnNt          d
‰ j        j        › d�¦  «        ‚|	�(t                               d
‰ j        j        › d�¦  «         |	‰ _
        |
�(t                               d‰ j        j        › d�¦  «         ‰                      dddi¬¦  «                             ¦   «         }|j        r+‰j        j        s‰j                             |j        ¦  «         |€Dt'          ‰d¦  «        r4t          ‰j        t*          t,          t.          t0          f¦  «        r‰j        }|€‰                      ‰||¬¦  «        }t5          ddg||g¦  «        D ]—\  }}t          |t6          ¦  «        r}|j        €vt;          t=          |¦  «        ¦  «        }t>          dt@          dtB          dtD          diŠˆfd„| #                    ¦   «         D ¦   «         }t          d|› d|› d|› d|› d �	¦  «        ‚Œ˜t          |tH          ¦  «        r$t          |tJ          ¦  «        stK          |¦  «        }t          |tH          ¦  «        r$t          |tJ          ¦  «        stK          |¦  «        }|€2|€0|j&        d!k    r%t          d"|j&        › d#‰ j        j        › d$�¦  «        ‚tO          ¦   «          (                    ‰ j
        rd n‰||||€|€|nd%||	|
||||¬&¦  «         ‰ j)        d%k    rd ‰ _)        i i d'œ‰ _*        d‰ _+        ‰  ‰  ‰  tY          d(„ ‰ j-        j.        D ¦   «         ¦  «        r t^          j0         1                    d)d*¦  «         td          �CtY          d+„ ‰ j-        j.        D ¦   «         ¦  «        r t^          j0         1                    d,d*¦  «         |€‰  3                    ‰ j4        ¦  «        }t          |tH          ¦  «        rïˆˆ fd-„| #                    ¦   «         D ¦   «         ‰ _5        t5          ddg||g¦  «        D ]³\  }}|€Œt          |tH          ¦  «        st          d.|› d/�¦  «        ‚tm          | 7                    ¦   «         ¦  «        tm          | 7                    ¦   «         ¦  «        z
  x}r>t          d0|› d1tq          |¦  «        › d2ts          |¦  «        d3k    rd4nd5› d6|› d7�	¦  «        ‚Œ´n‰  :                    |‰¦  «        ‰ _5        |�$t          |tv          ¦  «        sty          |¦  «        }|‰ _=        ‰ j>        �‰  ?                    |d¬8¦  «        ‰ _>        ‰ j)        �‰  ?                    |d¬8¦  «        ‰ _)        i ‰ _@        ‰  A                    |¦  «         d S )9NzTo train a z˜ model, you need to install the `accelerate` and `datasets` modules. You can do so with the `train` extra:
pip install -U "sentence-transformers[train]"Útmp_trainerzNo `args` passed, using `z(output_dir=z)`.)Ú
output_dirzPlease pass an instance of `z` as the `args` argument.ú`z4` requires either a `model` or `model_init` argumentz‹` requires either a `model` or `model_init` argument, but not both. `model_init` will overwrite your model when calling the `train` method.z7`compute_metrics` is currently not compatible with the z†. Please use the `evaluator` argument instead for detailed evaluation metrics, or the `eval_dataset` argument for the evaluation loss.ÚunusedÚuse_configured_stateT)ri   Úaccelerator_configÚ	processor)rK   rM   rH   ÚtrainÚevalÚstringÚint64Úfloat32Úboolc           
     óx   •— i | ]6\  }}|t          ‰                     t          |¦  «        d ¦  «        ¦  «        “Œ7S )Únull)rD   ÚgetÚtype)Ú.0ÚkeyÚvalueÚnaive_type_mappings      €ú`/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/sentence_transformers/base/trainer.pyú
<dictcomp>z(BaseTrainer.__init__.<locals>.<dictcomp>î   sM   ø€ ð $ð $ð $ÙPZÐPSÐUZ�C�Ð1×5Ò5µd¸5±k´kÀ6ÑJÔJÑKÔKð$ð $ð $ó    zThe provided `z6_dataset` must have Features. Specify them with e.g.:
z_dataset = z_dataset.cast(Features(zÕ))
or by providing the Features to the IterableDataset initialization method. See the Datasets documentation for more information on dataset Features: https://huggingface.co/docs/datasets/en/about_dataset_featuresÚnoz%You have set `args.eval_strategy` to zu, but you didn't provide an `eval_dataset` or an `evaluator`. Either provide an `eval_dataset` or an `evaluator` to `z7`, or set `args.eval_strategy='no'` to skip evaluation.Údummy)rK   rM   rV   rO   rQ   rH   rY   r[   r]   r_   ra   rc   )ro   rp   c              3  ó@   K  — | ]}t          |t          ¦  «        V — Œd S ©N)Ú
isinstancer   ©ry   Úcallbacks     r}   ú	<genexpr>z'BaseTrainer.__init__.<locals>.<genexpr>&  s,   è è € ÐcÐc°x�z˜(¥MÑ2Ô2ÐcÐcÐcÐcÐcÐcr   ÚWANDB_PROJECTzsentence-transformersc              3  ó@   K  — | ]}t          |t          ¦  «        V — Œd S rƒ   )r„   rE   r…   s     r}   r‡   z'BaseTrainer.__init__.<locals>.<genexpr>(  s=   è è € ð /
ð /
Ø6>�J�x¥Ñ1Ô1ð/
ð /
ð /
ð /
ð /
ð /
r   ÚTRACKIO_PROJECTc                óD   •— i | ]\  }}|‰                      |‰¦  «        “ŒS © )Úprepare_loss)ry   Údataset_nameÚloss_fnrK   Úselfs      €€r}   r~   z(BaseTrainer.__init__.<locals>.<dictcomp>1  s1   ø€ ÐsÐsÐsÑMbÈ\Ð[b˜ t×'8Ò'8¸À%Ñ'HÔ'HÐsÐsÐsr   z,If the provided `loss` is a dict, then the `z"_dataset` must be a `DatasetDict`.z:If the provided `loss` is a dict, then all keys from the `z;_dataset` dictionary must occur in `loss` also. Currently, z occuré   ÚsÚ z in `z_dataset` but not in `loss`.©rŽ   )Br>   ÚRuntimeErrorÚmodel_classÚ__name__ÚloggerÚinfoÚtraining_args_classr„   Ú
ValueErrorr<   rY   Úcall_model_initÚ	__class__ÚwarningÚto_dictÚhub_model_idÚmodel_card_dataÚmodel_idÚset_model_idÚhasattrrn   r   r   r   r   Úget_data_collatorÚziprB   Úcolumn_namesÚnextÚiterÚstrÚintÚfloatrt   ÚitemsÚdictrA   Úeval_strategyÚsuperÚ__init__rQ   Úaccum_loss_componentsÚcan_return_lossÚanyÚcallback_handlerr]   ÚosÚenvironÚ
setdefaultrE   Úget_default_lossrK   rR   ÚsetÚkeysÚsortedÚlenr�   r+   r,   rT   rO   Úpreprocess_datasetÚ_eval_dataloadersÚadd_model_card_callback)r�   rK   rM   rO   rQ   rR   rT   rV   rH   rY   r[   r]   r_   ra   rc   ri   Údefault_args_dictrŽ   ÚdatasetÚsampleÚexample_featuresÚmissingr|   r�   s   ``                    @€r}   r±   zBaseTrainer.__init__”   s‡  øøøø€ õ4 %Ñ&Ô&ð 	Ýð@˜dÔ.Ô7ð @ð @ð @ñô ð ð ˆ<Ø&ˆJÝ�KŠKÐr°DÔ4LÔ4UÐrÐrÐcmÐrÐrÐrÑsÔsÐsØ×+Ò+°zÐ+ÑBÔBˆDˆDÝ˜D $Ô":Ñ;Ô;ð 	ÝØl­x¸Ô8PÑ/QÔ/QÐlÐlÐlñô ð ð ˆ=ØÐ%Ø",�”Ø×,Ò,Ñ.Ô.��å"Ð#t t¤~Ô'>Ð#tÐ#tÐ#tÑuÔuÐuàÐ%Ý—’ð^˜œÔ/ð ^ð ^ð ^ñô ð ð )ˆDŒOàÐ&Ý�NŠNð'È$Ì.ÔJað 'ð 'ð 'ñô ð ð !×4Ò4ØÐ5KÈTÐ4Rð 5ñ 
ô 
ç
Š'‰)Œ)ð 	ð Ôð 	B UÔ%:Ô%Cð 	BØÔ!×.Ò.¨tÔ/@ÑAÔAÐAð Ð$Ý˜˜{Ñ+Ô+ð %åØ”Õ"9Õ;MÕOeÕguÐ!vñô ð %ð  %œÐàÐ Ø ×2Ò2¸ÀTÐ\lÐ2ÑmÔmˆMå%(¨'°6Ð):¸]ÈLÐ<YÑ%ZÔ%Zð 	ð 	Ñ!ˆL˜'Ý˜'¥?Ñ3Ô3ð ¸Ô8LÐ8TÝ�d 7™mœmÑ,Ô,�Ý&)¨8µS¸'Å5È)ÕUYÐ[aÐ%bÐ"ð$ð $ð $ð $Ø^d×^jÒ^jÑ^lÔ^lð$ñ $ô $Ð õ !ðU \ð Uð UØ#ðUð UØ0<ðUð UØUeðUð Uð Uñô ð øõ �m¥TÑ*Ô*ð 	7µ:¸mÍ[Ñ3YÔ3Yð 	7Ý'¨Ñ6Ô6ˆMÝ�l¥DÑ)Ô)ð 	5µ*¸\Í;Ñ2WÔ2Wð 	5Ý& |Ñ4Ô4ˆLð Ð IÐ$5¸$Ô:LÐPTÒ:TÐ:TÝðG¸Ô8Jð Gð GØJNÌ.ÔJaðGð Gð Gñô ð õ 	‰Œ×ÒØœ/Ð4�$�$¨uØØ'Ø'Ø)5Ð)AÀYÐEV˜˜Ð\cØ-Ø!Ø+ØØ!Ø%=Ø*Gð 	ñ 	
ô 	
ð 	
ð Ô Ò'Ð'Ø $ˆDÔð 02¸2Ð%>Ð%>ˆÔ"ð  $ˆÔàÐØÐ(ØÐ,õ ÐcÐcÀ4ÔCXÔCbÐcÑcÔcÑcÔcð 	LÝŒJ×!Ò! /Ð3JÑKÔKÐKÝÐ&­3ð /
ð /
ØBFÔBWÔBað/
ñ /
ô /
ñ ,
ô ,
Ð&õ ŒJ×!Ò!Ð"3Ð5LÑMÔMÐMàˆ<Ø×(Ò(¨¬Ñ4Ô4ˆDå�d�DÑ!Ô!ð 	7ØsÐsÐsÐsÐsÐfj×fpÒfpÑfrÔfrÐsÑsÔsˆDŒIÝ),¨g°vÐ->ÀÐP\Ð@]Ñ)^Ô)^ð ð Ñ%�˜gØ�?ØÝ! '­4Ñ0Ô0ð Ý$ØwÀ|ÐwÐwÐwñô ð õ " '§,¢,¡.¤.Ñ1Ô1µC¸¿	º	¹¼Ñ4DÔ4DÑDÐD�7ð Ý$ðOÐUað Oð OÝ&,¨W¡o¤oðOð OÝDGÈÁLÄLÐTUÒDUÐDU¸S¸SÐ[]ðOð OØdpðOð Oð Oñô ð ððð ×)Ò)¨$°Ñ6Ô6ˆDŒIð Ð ­°I½}Ñ)MÔ)MÐ Ý+¨IÑ6Ô6ˆIØ"ˆŒàÔÐ)Ø!%×!8Ò!8¸ÐU\Ð!8Ñ!]Ô!]ˆDÔØÔÐ(Ø $× 7Ò 7¸ÐSYÐ 7Ñ ZÔ ZˆDÔØ8:ˆÔØ×$Ò$Ð%6Ñ7Ô7Ð7Ð7Ð7r   r.   r8   r*   c                óÆ   — t           d„ |                     ¦   «         D ¦   «         v r|j        st          d¦  «        ‚|                      |j        |j        |j        ¬¦  «        S )as  
        Load the data collator for the trainer.

        Args:
            model (:class:`~sentence_transformers.base.model.BaseModel`):
                The model to train, evaluate or use for predictions.
            args (:class:`~sentence_transformers.base.training_args.BaseTrainingArguments`):
                The arguments to tweak for training.
            processing_class (Union[:class:`transformers.PreTrainedTokenizerBase`, :class:`transformers.BaseImageProcessor`, :class:`transformers.FeatureExtractionMixin`, :class:`transformers.ProcessorMixin`], *optional*):
                The processing class to use for tokenization or image processing.
        Returns:
            :class:`BaseDataCollator`: The data collator to use for the trainer

        .. note::

            This method can be overridden by subclassing the trainer to use a custom data collator.
        c                ó   — g | ]	}|j         ‘Œ
S rŒ   ©r�   ©ry   Úmodules     r}   ú
<listcomp>z1BaseTrainer.get_data_collator.<locals>.<listcomp>h  s   € ÐFÐFÐF¨6�fÔ&ÐFÐFÐFr   al  You are using a Router module in your model, but you did not provide a `router_mapping` in the training arguments. This means that the Router module will not be able to route the inputs to the correct submodules. Please provide a `router_mapping` that maps column names to routes, e.g. {'column_one': 'query', 'column_two': 'document', 'column_three': 'document'}.)Úpreprocess_fnÚrouter_mappingÚprompts)r1   ÚchildrenrÍ   r›   Údata_collator_classÚ
preprocessrÎ   )r�   rK   rM   rH   s       r}   r¥   zBaseTrainer.get_data_collatorM  sx   € õ6 ÐFÐF°U·^²^Ñ5EÔ5EÐFÑFÔFÐFÐFÈtÔObÐFÝðfñô ð ð ×'Ò'ØÔ*ØÔ.Ø”Lð (ñ 
ô 
ð 	
r   rÁ   údict[str, Any]c                ó¶   — |                       |¦  «        }|                      |¦  «         |                     | j        | j        | j        | j        | ¬¦  «         dS )a)  
        Add a callback responsible for automatically tracking data required for the automatic model card generation

        This method is called in the ``__init__`` method of the trainer subclass.

        Args:
            default_args_dict (Dict[str, Any]): A dictionary of the default training arguments, so we can determine
                which arguments have been changed for the model card.

        .. note::

            This method can be overridden by subclassing the trainer to remove/customize this callback in custom uses cases
        )rK   ÚtrainerN)Úmodel_card_callback_classÚadd_callbackÚon_init_endrM   ÚstateÚcontrolrK   )r�   rÁ   Úmodel_card_callbacks      r}   rÀ   z#BaseTrainer.add_model_card_callbackv  s^   € ð #×<Ò<Ð=NÑOÔOÐØ×ÒÐ-Ñ.Ô.Ð.Ø×'Ò'¨¬	°4´:¸t¼|ÐSWÔS]ÐgkÐ'ÑlÔlÐlÐlÐlr   c                óŽ  •— t          ¦   «                              |¬¦  «        }t          | d¦  «        s|S t          | j        t
          ¦  «        r�| j                             ¦   «         D ]f\  }}t          |t          j        j	        ¦  «        s ||¦  «        | j        |<   Œ8t          |d¦  «        r|  
                    ||¦  «        | j        |<   Œgntt          | j        t          j        j	        ¦  «        s|                      |¦  «        | _        n5t          | j        d¦  «        r |  
                    | j        |¦  «        | _        |S )N)ÚtrialrR   rK   )r°   rœ   r¤   r„   rR   r®   r­   Útorchr   ÚModuleÚoverride_model_in_loss)r�   rÜ   rK   rz   r�   r�   s        €r}   rœ   zBaseTrainer.call_model_init‰  s2  ø€ Ý‘”×'Ò'¨eÐ'Ñ4Ô4ˆå�t˜VÑ$Ô$ð 	ØˆLõ �d”i¥Ñ&Ô&ð 	FØ $¤	§¢Ñ 1Ô 1ð Qð Q‘��Wå! '­5¬8¬?Ñ;Ô;ð QØ%, W¨U¡^¤^�D”I˜c‘N�Nå˜W gÑ.Ô.ð QØ%)×%@Ò%@ÀÈ%Ñ%PÔ%P�D”I˜c‘NøðQõ ˜DœI¥u¤x¤Ñ7Ô7ð 	FØŸ	š	 %Ñ(Ô(ˆDŒIˆIõ �T”Y Ñ(Ô(ð 	FØ×3Ò3°D´I¸uÑEÔEˆDŒIØˆr   útorch.nn.Modulec           
     ó’  — ddl m} |                     ¦   «         D ]«\  }}|dk    r\t          ||¦  «        rLdD ]A}t	          ||¦  «        r/t	          ||¦  «        st          ||t          ||¦  «        ¦  «         ŒB||_        Œgt          |t          j	        j
        ¦  «        r%t          |||                      ||¦  «        ¦  «         Œ¬|S )Nr   r-   rK   )rÑ   Úget_embedding_dimension)Ú sentence_transformers.base.modelr.   Únamed_childrenr„   r¤   ÚsetattrÚgetattrrK   rÝ   r   rÞ   rß   )r�   rR   rK   r.   ÚnameÚchildÚattrs          r}   rß   z"BaseTrainer.override_model_in_loss¢  sê   € Ø>Ð>Ð>Ð>Ð>Ð>à×.Ò.Ñ0Ô0ð 
	Oð 
	O‰KˆD�%Ø�wŠˆ¥:¨e°YÑ#?Ô#?ˆð Fð Cð C�DÝ˜u dÑ+Ô+ð CµG¸EÀ4Ñ4HÔ4Hð CÝ  t­W°U¸DÑ-AÔ-AÑBÔBÐBøØ"�”
�
Ý˜E¥5¤8¤?Ñ3Ô3ð OÝ˜˜d D×$?Ò$?ÀÀuÑ$MÔ$MÑNÔNÐNøØˆr   ú8Callable[[BaseModel], torch.nn.Module] | torch.nn.Modulec                óê  — t          |t          j        j        ¦  «        r|                     |j        ¦  «        }n# ||¦  «                             |j        ¦  «        }t          d„ |                     ¦   «         D ¦   «         ¦  «        rjt          |d         t          ¦  «        r*d„ |d         j	         
                    ¦   «         D ¦   «         }n	|d         g}|D ]}t          |d¦  «        rd|_        Œ|S )Nc              3  ó8   K  — | ]}t          |d d¦  «        V — ŒdS )Úrequires_media_countsFN)ræ   rÉ   s     r}   r‡   z+BaseTrainer.prepare_loss.<locals>.<genexpr>¾  s/   è è € Ð\Ð\À6�w�vÐ6¸Ñ>Ô>Ð\Ð\Ð\Ð\Ð\Ð\r   r   c                ó   — g | ]
}|d          ‘ŒS )r   rŒ   )ry   Úroutes     r}   rË   z,BaseTrainer.prepare_loss.<locals>.<listcomp>À  s   € Ð UÐ UÐ U¨e  q¤Ð UÐ UÐ Ur   Útrack_media_countsT)r„   rÝ   r   rÞ   ÚtoÚdevicer´   Úmodulesr1   Úsub_modulesÚvaluesr¤   rð   )r�   rR   rK   Úinput_modulesrÊ   s        r}   r�   zBaseTrainer.prepare_loss²  sì   € õ
 �d�EœHœOÑ,Ô,ð 	0Ø—7’7˜5œ<Ñ(Ô(ˆDˆDà�4˜‘;”;—>’> %¤,Ñ/Ô/ˆDõ Ð\Ð\ÈTÏ\Ê\É^Ì^Ð\Ñ\Ô\Ñ\Ô\ð 	5Ý˜% œ(¥FÑ+Ô+ð +Ø UÐ U°u¸Q´xÔ7K×7RÒ7RÑ7TÔ7TÐ UÑ UÔ U��à!& q¤ 
�Ø'ð 5ð 5�Ý˜6Ð#7Ñ8Ô8ð 5Ø04�FÔ-øàˆr   c                ó   — d S rƒ   rŒ   )r�   rK   s     r}   r¹   zBaseTrainer.get_default_lossÉ  s   € àˆr   FÚinputsúdict[str, torch.Tensor | Any]Úreturn_outputsrt   ú2torch.Tensor | tuple[torch.Tensor, dict[str, Any]]c                ó(  — |                      dd¦  «        }|                      |¦  «        \  }}| j        }t          |t          ¦  «        r
|r||         }|| j        k    r1t          |d¦  «        r!|j        |k    r|                      ||¦  «        } |||¦  «        }	t          |	t          ¦  «        rZ|  	                    |	¦  «         t          j        t          |	                     ¦   «         ¦  «        ¦  «                             ¦   «         }	|r|	i fS |	S )a‘  
        Computes the loss for the BaseModel model.

        It uses ``self.loss`` to compute the loss, which can be a single loss function or a dictionary of loss functions
        for different datasets. If the loss is a dictionary, the dataset name is expected to be passed in the inputs
        under the key "dataset_name". This is done automatically in the ``add_dataset_name_column`` method.
        Note that even if ``return_outputs = True``, the outputs will be empty, as the BaseModel losses do not
        return outputs.

        Args:
            model (BaseModel): The BaseModel model.
            inputs (Dict[str, Union[torch.Tensor, Any]]): The input data for the model.
            return_outputs (bool, optional): Whether to return the outputs along with the loss. Defaults to False.
            num_items_in_batch (int, optional): The number of items in the batch. Defaults to None. Unused, but required by the transformers Trainer.

        Returns:
            Union[torch.Tensor, Tuple[torch.Tensor, Dict[str, Any]]]: The computed loss. If `return_outputs` is True, returns a tuple of loss and outputs. Otherwise, returns only the loss.
        rŽ   NrK   )ÚpopÚcollect_featuresrR   r„   r®   Úmodel_wrappedr¤   rK   rß   Útrack_loss_componentsrÝ   ÚstackÚlistrõ   Úsum)
r�   rK   rø   rú   Únum_items_in_batchrŽ   ÚfeaturesÚlabelsr�   rR   s
             r}   Úcompute_losszBaseTrainer.compute_lossÍ  s  € ð2 —z’z .°$Ñ7Ô7ˆØ×0Ò0°Ñ8Ô8Ñˆ�&Ø”)ˆå�g�tÑ$Ô$ð 	,¨ð 	,Ø˜lÔ+ˆGð
 �TÔ'Ò'Ð'Ý˜ Ñ)Ô)ð (à” Ò&Ð&à×1Ò1°'¸5ÑAÔAˆGØˆw�x Ñ(Ô(ˆÝ�d�DÑ!Ô!ð 	:Ø×&Ò& tÑ,Ô,Ð,Ý”;�t D§K¢K¡M¤MÑ2Ô2Ñ3Ô3×7Ò7Ñ9Ô9ˆDØð 	ð
 ˜�8ˆOØˆr   údict[str, torch.Tensor]c                óÜ  — | j         j        rdnd}|                     ¦   «         D ]í\  }}|                     ¦   «         }| j        j        r„t          j        |¦  «        st          j        |¦  «        r\|| j	        |         vr"t          j
        d|j        |j        ¬¦  «        }n+| j	        |         |         d| j        j        z   | j        z
  z  }|| j	        |         vr|| j	        |         |<   ŒÉ| j	        |         |         |z   | j	        |         |<   Œîd| j	        |         vr/t          j
        dt           |j        ¬¦  «        | j	        |         d<   | j	        |         dxx         dz  cc<   d S )Nro   rp   ç        ©Údtyperò   r‘   Ústepsr   )rK   Útrainingr­   ÚdetachrM   Úlogging_nan_inf_filterrÝ   ÚisnanÚisinfr²   Útensorr  rò   rØ   Úglobal_stepÚ_globalstep_last_loggedr«   )r�   rR   Útraining_typerz   r{   s        r}   r   z!BaseTrainer.track_loss_components  s…  € Ø#'¤:Ô#6ÐB˜˜¸FˆØŸ*š*™,œ,ð 	xð 	x‰JˆC�ð —L’L‘N”NˆEàŒyÔ/ð µU´[ÀÑ5GÔ5Gð Í5Ì;ÐW\ÑK]ÔK]ð Ø˜dÔ8¸ÔGÐGÐGÝ!œL¨°E´KÈÌÐUÑUÔU�E�Eà Ô6°}ÔEÀcÔJØ˜DœJÔ2Ñ2°TÔ5QÑQñ�Eð ˜$Ô4°]ÔCÐCÐCØAF�Ô*¨=Ô9¸#Ñ>Ð>àAEÔA[Ð\iÔAjÐknÔAoÐrwÑAw�Ô*¨=Ô9¸#Ñ>Ð>à˜$Ô4°]ÔCÐCÐCÝAFÄÈaÕWZÐchÔcoÐApÑApÔApˆDÔ& }Ô5°gÑ>ØÔ" =Ô1°'Ð:Ð:Ô:¸aÑ?Ð:Ð:Ñ:Ð:Ð:r   Úlogsúdict[str, float]Ú
start_timeúfloat | Nonec                ón  •— d }d|v rd}nd|v rd}|�r^|                      ¦   «         }t          | d¦  «        r!|                      | j        |         ¦  «        }n(ddlm}  || j        |         | j        j        ¬¦  «        }d	|v rí|                     d	¦  «         	                    ¦   «          
                    ¦   «         }| j        |         d	xx         dz  cc<   |                     ¦   «         D ]„\  }}|d	k    rŒ|dk    r|› d
|› �n|}	t          | 	                    ¦   «         |z   
                    ¦   «         d¦  «        ||	<   t          j        d|j        |j        ¬¦  «        | j        |         |<   Œ…|�"t#          ¦   «                              ||¦  «        S t#          ¦   «                              |¦  «        S )NrR   ro   Ú	eval_lossrp   Ú_nested_gatherr   )Únested_gather)Úparallel_moder  Ú_é   r
  r  )Úcopyr¤   r  r²   Útransformers.trainer_pt_utilsr  rM   r  rw   r  Úitemr­   ÚroundrÝ   r  r  rò   r°   Úlog)r�   r  r  r  Úaccum_lossesr  r  rz   r{   Úlog_keyr�   s             €r}   r&  zBaseTrainer.log  së  ø€ ØˆØ�Tˆ>ˆ>Ø#ˆMˆMØ˜DÐ Ð Ø"ˆMàñ 	ð —9’9‘;”;ˆDõ �tÐ-Ñ.Ô.ð Ø#×2Ò2°4Ô3MÈmÔ3\Ñ]Ô]��àGÐGÐGÐGÐGÐGà,˜}ØÔ.¨}Ô=ÈTÌYÔMdð ñ  ô  �ð ˜,Ð&Ð&Ø$×(Ò(¨Ñ1Ô1×5Ò5Ñ7Ô7×<Ò<Ñ>Ô>�ØÔ*¨=Ô9¸'ÐBÐBÔBÀaÑGÐBÐBÑBà".×"4Ò"4Ñ"6Ô"6ð ð ‘J�C˜Ø˜g’~�~Ø Ø:GÈ6Ò:QÐ:Q Ð6Ð6°Ð6Ð6Ð6ÐWZ�GÝ$)¨5¯9ª9©;¬;¸Ñ+>×*DÒ*DÑ*FÔ*FÈÑ$JÔ$J�D˜‘MÝEJÄ\Ø 5¤;°u´|ðFñ Fô F�DÔ.¨}Ô=¸cÑBÐBð Ð!Ý‘7”7—;’;˜t ZÑ0Ô0Ð0å‘7”7—;’;˜tÑ$Ô$Ð$r   ú9tuple[list[dict[str, torch.Tensor]], torch.Tensor | None]c                óv  ‡— d}g }t          ¦   «         }|D ]Š}dŠ|D ]4}|                     d|z   ¦  «        r|dt          |¦  «         …         Š nŒ5‰�‰|v rŒB|                     ‰¦  «         |                     ˆfd„|                     ¦   «         D ¦   «         ¦  «         Œ‹|                     dd¦  «        }||fS )aÛ  Turn the inputs from the dataloader into the separate model inputs & the labels.

        Example::

            >>> list(inputs.keys())
            ['return_loss', 'label', 'sentence_0_input_ids', 'sentence_0_token_type_ids', 'sentence_0_attention_mask', 'sentence_1_input_ids', 'sentence_1_token_type_ids', 'sentence_1_attention_mask']
            >>> features, labels = self.collect_features(inputs)
            >>> len(features)
            2
            >>> list(features[0].keys())
            ['input_ids', 'token_type_ids', 'attention_mask']
            >>> list(features[1].keys())
            ['input_ids', 'token_type_ids', 'attention_mask']
            >>> torch.equal(labels, inputs["label"])
            True
        )Ú	input_idsÚsentence_embeddingÚpixel_valuesÚinput_featuresÚinput_valuesÚpixel_values_videosNr   c                óp   •— i | ]2\  }}|                      ‰¦  «        ¯|t          ‰¦  «        d …         |“Œ3S rƒ   )Ú
startswithr½   )ry   rz   r{   Úprefixs      €r}   r~   z0BaseTrainer.collect_features.<locals>.<dictcomp>i  sC   ø€ ÐrÐrÐr¹:¸3ÀÐ[^×[iÒ[iÐjpÑ[qÔ[qÐr˜S¥ V¡¤  Ô/°ÐrÐrÐrr   Úlabel)rº   Úendswithr½   ÚaddÚappendr­   rw   )	r�   rø   Úfeature_suffixesr  Úseen_prefixesÚcolumnÚsuffixr  r3  s	           @r}   rþ   zBaseTrainer.collect_featuresB  sð   ø€ ð(
Ðð ˆÝ™œˆØð 		tð 		tˆFØˆFØ*ð ð �Ø—?’? 3¨¡<Ñ0Ô0ð Ø# N¥s¨6¡{¤{ l NÔ3�FØ�Eðð ˆ~ ¨=Ð!8Ð!8ØØ×Ò˜fÑ%Ô%Ð%Ø�OŠOÐrÐrÐrÐrÈÏÊÉÌÐrÑrÔrÑsÔsÐsÐsØ—’˜G TÑ*Ô*ˆØ˜ÐÐr   rp   ú)str | Dataset | dict[str, Dataset] | NoneÚignore_keysúlist[str] | NoneÚmetric_key_prefixrª   c                ó¦   •— |�,t          |t          ¦  «        s|                      |d¬¦  «        }t          ¦   «                              |||¦  «        S )Nrp   r”   )r„   rª   r¾   r°   Úevaluate)r�   rQ   r=  r?  r�   s       €r}   rA  zBaseTrainer.evaluatem  sO   ø€ ð Ð#­J°|ÅSÑ,IÔ,IÐ#Ø×2Ò2°<ÈfÐ2ÑUÔUˆLÝ‰wŒw×Ò ¨kÐ;LÑMÔMÐMr   Ú
dataloaderr   ÚdescriptionÚprediction_loss_onlyúbool | Noner   c                óö  •— t          ¦   «                              |||||¬¦  «        }| j        €|S | j        rlt	          | j        t          ¦  «        rR|                     d¦  «        r=|dd …         t          | j         	                    ¦   «         ¦  «        d         k    rd}n|S |  
                    ¦   «         rt          ¦   «         nt          t          j        ¦  «        5  | j        j        }|�6t"          j                             |d¦  «        }t#          j        |d¬¦  «         |                      | j        || j        j        | j        j        ¬¦  «        }d d d ¦  «         n# 1 swxY w Y   t	          |t          ¦  «        sd	|i}t          | 	                    ¦   «         ¦  «        D ]7}	|	                     |› d
�¦  «        s|                     |	¦  «        ||› d
|	› �<   Œ8|j                             |¦  «         |S )N)rB  rC  rD  r=  r?  Úeval_é   r   rp   T©Úexist_ok)Úoutput_pathÚepochr  rT   r   )r°   Úevaluation_looprT   Úis_in_trainr„   rQ   r®   r2  r  r»   Úis_local_process_zeror   r;   ÚloggingÚINFOrM   ri   r¶   ÚpathÚjoinÚmakedirsrK   rØ   rL  r  rý   ÚmetricsÚupdate)r�   rB  rC  rD  r=  r?  ÚoutputrK  Úevaluator_metricsrz   r�   s             €r}   rM  zBaseTrainer.evaluation_loopx  sP  ø€ õ ‘”×(Ò(Ø!Ø#Ø!5Ø#Ø/ð )ñ 
ô 
ˆð Œ>Ð!ØˆMð
 Ôð 	¥
¨4Ô+<½dÑ CÔ Cð 	ÐHY×HdÒHdÐelÑHmÔHmð 	Ø    Ô$­¨TÔ->×-CÒ-CÑ-EÔ-EÑ(FÔ(FÀqÔ(IÒIÐIØ$*Ð!Ð!à�à"×8Ò8Ñ:Ô:Ð]�[‰]Œ]ˆ]ÅÕPWÔP\Ñ@]Ô@]ð 	ð 	Øœ)Ô.ˆKØÐ&Ý œgŸlšl¨;¸Ñ?Ô?�Ý”˜K°$Ð7Ñ7Ô7Ð7Ø $§¢Ø”
¨¸4¼:Ô;KÐSWÔS]ÔSið !/ñ !ô !Ðð	ð 	ð 	ñ 	ô 	ð 	ð 	ð 	ð 	ð 	ð 	øøøð 	ð 	ð 	ð 	õ Ð+­TÑ2Ô2ð 	AØ!,Ð.?Ð @Ðõ Ð)×.Ò.Ñ0Ô0Ñ1Ô1ð 	]ð 	]ˆCØ—>’>Ð%6Ð"9Ð"9Ð"9Ñ:Ô:ð ]ØBS×BWÒBWÐX[ÑB\ÔB\Ð!Ð%6Ð">Ð">¸Ð">Ð">Ñ?øàŒ×ÒÐ/Ñ0Ô0Ð0àˆs   ÃA7E"Å"E&Å)E&c           	     ó  — t                                d| j        j        › d| j        j        › d�¦  «         	 | j        j        x}rH|                     dd¦  «        d         }| j        j                             t          |¦  «        ¦  «         n# t          $ r Y nw xY w	 |                      | j        j        ¦  «         d S # t          $ rB}t                                d| j        j        › dt          |¦  «        › �¦  «         Y d }~d S d }~ww xY w)	NzLoading best model from z	 (score: z).ú-r‘   éÿÿÿÿz#Could not load the best model from z	. Error: )r˜   r™   rØ   Úbest_model_checkpointÚbest_metricÚrsplitrK   r¡   Úset_best_model_stepr«   Ú	ExceptionÚ_load_from_checkpointÚerrorrª   )r�   Ú
checkpointÚstepÚexcs       r}   Ú_load_best_modelzBaseTrainer._load_best_model©  s(  € å�ŠÐt¨t¬zÔ/OÐtÐtÐZ^ÔZdÔZpÐtÐtÐtÑuÔuÐuð	Ø!œZÔ=Ð=ˆzð JØ!×(Ò(¨¨aÑ0Ô0°Ô4�Ø”
Ô*×>Ò>½sÀ4¹y¼yÑIÔIÐIøøÝð 	ð 	ð 	ØˆDð	øøøð	Ø×&Ò& t¤zÔ'GÑHÔHÐHÐHÐHøÝð 	ð 	ð 	Ý�LŠLÐt¸t¼zÔ?_ÐtÐtÕjmÐnqÑjrÔjrÐtÐtÑuÔuÐuØˆFˆFˆFˆFˆFøøøøð	øøøs*   ·AB Â
BÂBÂC  Ã 
DÃ
7DÄDrÂ   r@   rŽ   ú
str | Nonec                ó   — t          |t          ¦  «        r3|                     ¦   «         D ]\  }}|                      ||¬¦  «         Œd S t	          |j        ¦  «        ddhz  x}r*t          d|r|dz   nd› dt          |¦  «        › d�¦  «        ‚d S )	Nr”   Úreturn_lossrŽ   z/The following column names are invalid in your ú r“   z	dataset: zH. Avoid using these column names, as they are reserved for internal use.)r„   r®   r­   Úvalidate_column_namesrº   r§   r›   r  )r�   rÂ   rŽ   Úoverlaps       r}   rk  z!BaseTrainer.validate_column_namesº  sá   € Ý�g�tÑ$Ô$ð 	Ø)0¯ª©¬ð Oð OÑ%�˜gØ×*Ò*¨7ÀÐ*ÑNÔNÐNÐNØˆFå˜'Ô.Ñ/Ô/°=À.Ð2QÑQÐQˆ7ð 	ÝðZÐXdÐBlÀ,ÐQTÑBTÐBTÐjlð Zð ZÕw{ð  }Dñ  xEô  xEð Zð Zð Zñô ð ð	ð 	r   r   Ú
batch_sizer«   Ú	drop_lastÚvalid_label_columnsÚ	generatorútorch.Generator | NoneÚseedúBatchSampler | Nonec                óþ  — |||||dœ}t          j        | j        j        ¦  «        r2t	          | j        j        t
          ¦  «        r | j        j        |fi |¤ŽS t          | j        j        ¦  «        r | j        j        |fi |¤ŽS t          |t          ¦  «        r6| j        j        t          j
        k    rt                               d¦  «         dS | j        j        t          j        k    rt          |fi |¤ŽS | j        j        t          j        k    rt          |fddi|¤ŽS | j        j        t          j        k    rt#          |fi |¤ŽS | j        j        t          j
        k    rt          t%          ||¬¦  «        fi |¤ŽS dS )aS  
        Returns the appropriate batch sampler based on the ``batch_sampler`` argument in ``self.args``.
        This batch sampler class supports ``__len__`` and ``__iter__`` methods, and is used as the ``batch_sampler``
        to create the :class:`torch.utils.data.DataLoader`.

        .. note::
            Override this method to provide a custom batch sampler.

        Args:
            dataset (Dataset): The dataset to sample from.
            batch_size (int): Number of samples per batch.
            drop_last (bool): If True, drop the last incomplete batch if the dataset size
                is not divisible by the batch size.
            valid_label_columns (List[str]): List of column names to check for labels.
                The first column name from ``valid_label_columns`` found in the dataset will
                be used as the label column.
            generator (torch.Generator, optional): Optional random number generator for shuffling
                the indices.
            seed (int): Seed for the random number generator to ensure reproducibility. Defaults to 0.
        )rm  rn  ro  rp  rr  úBWhen using an IterableDataset, you cannot specify a batch sampler.NÚprecompute_hashesT)rp  )ÚinspectÚisclassrM   Úbatch_samplerÚ
issubclassr2   Úcallabler„   rB   r9   ÚBATCH_SAMPLERr˜   rž   ÚNO_DUPLICATESr5   ÚNO_DUPLICATES_HASHEDÚGROUP_BY_LABELr3   r   )r�   rÂ   rm  rn  ro  rp  rr  Úbatch_sampler_kwargss           r}   Úget_batch_samplerzBaseTrainer.get_batch_samplerÆ  sª  € ð> %Ø"Ø#6Ø"Øð 
ð  
Ðõ Œ?˜4œ9Ô2Ñ3Ô3ð 	L½
À4Ä9ÔCZÕ\oÑ8pÔ8pð 	LØ*�4”9Ô*¨7ÐKÐKÐ6JÐKÐKÐKõ �D”IÔ+Ñ,Ô,ð 	LØ*�4”9Ô*¨7ÐKÐKÐ6JÐKÐKÐKõ �g�Ñ/Ô/ð 	ØŒyÔ&­-Ô*EÒEÐEÝ—’ÐcÑdÔdÐdØ�4ð Œ9Ô"¥mÔ&AÒAÐAÝ+¨GÐLÐLÐ7KÐLÐLÐLàŒ9Ô"¥mÔ&HÒHÐHÝ+¨GÐdÐdÀtÐdÐOcÐdÐdÐdàŒ9Ô"¥mÔ&BÒBÐBÝ+¨GÐLÐLÐ7KÐLÐLÐLàŒ9Ô"¥mÔ&AÒAÐAÝ&¥}°WÈ	Ð'RÑ'RÔ'RÐkÐkÐVjÐkÐkÐkð BÐAr   r   Úbatch_samplersúlist[BatchSampler]ú
int | Noner   c                óª  — |||dœ}t          j        | j        j        ¦  «        r2t	          | j        j        t
          ¦  «        r | j        j        |fi |¤ŽS t          | j        j        ¦  «        r | j        j        |fi |¤ŽS | j        j        t          j        k    rt          dd|i|¤ŽS | j        j        t          j
        k    rt          dd|i|¤ŽS dS )a/  
        Returns the appropriate multi-dataset batch sampler based on the ``multi_dataset_batch_sampler`` argument
        in ``self.args``. This batch sampler class supports ``__len__`` and ``__iter__`` methods, and is used as the
        ``batch_sampler`` to create the :class:`torch.utils.data.DataLoader`.

        .. note::
            Override this method to provide a custom multi-dataset batch sampler.

        Args:
            dataset (ConcatDataset): The concatenation of all datasets.
            batch_samplers (List[BatchSampler]): List of batch samplers for each dataset in the concatenated dataset.
            generator (torch.Generator, optional): Optional random number generator for shuffling the indices.
            seed (int, optional): Optional seed for the random number generator
        )r‚  rp  rr  rÂ   NrŒ   )rw  rx  rM   Úmulti_dataset_batch_samplerrz  r4   r{  r:   ÚROUND_ROBINr7   ÚPROPORTIONALr6   )r�   rÂ   r‚  rp  rr  Úmulti_batch_sampler_kwargss         r}   Úget_multi_dataset_batch_samplerz+BaseTrainer.get_multi_dataset_batch_sampler  s  € ð. -Ø"Øð&
ð &
Ð"õ Œ?˜4œ9Ô@ÑAÔAð 	`ÅjØŒIÔ1Õ3RñG
ô G
ð 	`ð 9�4”9Ô8¸Ð_Ð_ÐD^Ð_Ð_Ð_õ �D”IÔ9Ñ:Ô:ð 	`Ø8�4”9Ô8¸Ð_Ð_ÐD^Ð_Ð_Ð_ð Œ9Ô0Õ4MÔ4YÒYÐYÝ)ÐXÐX°'ÐXÐ=WÐXÐXÐXàŒ9Ô0Õ4MÔ4ZÒZÐZÝ+ÐZÐZ°GÐZÐ?YÐZÐZÐZð [ÐZr   ú'Dataset | DatasetDict | IterableDatasetÚdataset_kindc                ó^  ‡ ‡‡‡	— ‰ j         Št          j        ¦   «         Š	‰ j        j        �‰	                     ‰ j        j        ¦  «         ‰‰ j        j        ‰ j        j        ‰ j        j        ‰ j        j	        dœ}t          |t          ¦  «        rX|                     ‰‰ j        j        dœ¦  «         ‰ j        j        t          j        k    rt"                               d¦  «         �n;t          |t&          ¦  «        rt)          d¦  «        ‚t          |t*          ¦  «        r¨|                     ¦   «         D ]&}t          |t          ¦  «        rt)          d¦  «        ‚Œ'ˆˆˆ	ˆ fd„|                     ¦   «         D ¦   «         }t/          |                     ¦   «         ¦  «        }‰                      ||‰	‰ j        j        ¬¦  «        }||d	<   nZt          |t2          ¦  «        r/‰                      |‰‰ j        j        ‰j        ‰	¬
¦  «        }||d	<   nt)          d|› d|› d�¦  «        ‚t9          |fi |¤ŽS )a[  Shared logic for building train/eval/test DataLoaders.

        Args:
            dataset: The dataset to build a DataLoader for.
            batch_size: The batch size to use.
            dataset_kind: A label for error messages, e.g. "train", "eval", or "test".

        Returns:
            A prepared DataLoader for the given dataset.
        N)Ú
collate_fnÚnum_workersÚ
pin_memoryÚpersistent_workersÚprefetch_factor)rm  rn  ru  zcSentence Transformers is not compatible with IterableDatasetDict. Please use a DatasetDict instead.zYSentence Transformers is not compatible with a DatasetDict containing an IterableDataset.c           	     ób   •— g | ]+}‰                      |‰‰j        j        ‰j        ‰¬ ¦  «        ‘Œ,S )©rm  rn  ro  rp  )r�  rM   Údataloader_drop_lastro  )ry   Úsub_datasetrm  rV   rp  r�   s     €€€€r}   rË   z1BaseTrainer._build_dataloader.<locals>.<listcomp>g  sW   ø€ ð 	ð 	ð 	ð  ð ×&Ò&ØØ)Ø"œiÔ<Ø(5Ô(IØ'ð 'ñ ô ð	ð 	ð 	r   )rÂ   r‚  rp  rr  ry  r”  zUnsupported `zC_dataset` type. Use a Dataset, DatasetDict, or IterableDataset for ú.)rV   rÝ   Ú	GeneratorrM   rr  Úmanual_seedÚdataloader_num_workersÚdataloader_pin_memoryÚdataloader_persistent_workersÚdataloader_prefetch_factorr„   rB   rV  r•  ry  r9   r|  r˜   rž   rC   r›   rA   rõ   r   rŠ  r@   r�  ro  r   )
r�   rÂ   rm  rŒ  Údataloader_paramsr–  r‚  ry  rV   rp  s
   ` `     @@r}   Ú_build_dataloaderzBaseTrainer._build_dataloader3  sš  øøøø€ ð  Ô*ˆå”OÑ%Ô%ˆ	ØŒ9Œ>Ð%Ø×!Ò! $¤)¤.Ñ1Ô1Ð1ð (Øœ9Ô;Øœ)Ô9Ø"&¤)Ô"IØ#œyÔCð
ð 
Ðõ �g�Ñ/Ô/ð 6	Ø×$Ò$à",Ø!%¤Ô!?ðð ñô ð ð ŒyÔ&­-Ô*EÒEÐEÝ—’ÐcÑdÔdÐdùå˜Õ!4Ñ5Ô5ð ,	ÝØuñô ð õ ˜¥Ñ-Ô-ð '	Ø&Ÿ~š~Ñ/Ô/ð ð �Ý˜k­?Ñ;Ô;ð Ý$Øsñô ð ðð
	ð 	ð 	ð 	ð 	ð 	ð 	ð $+§>¢>Ñ#3Ô#3ð	ñ 	ô 	ˆNõ $ G§N¢NÑ$4Ô$4Ñ5Ô5ˆGØ ×@Ò@ØØ-Ø#Ø”Y”^ð	 Añ ô ˆMð 2?Ð˜oÑ.Ð.å˜¥Ñ)Ô)ð 	Ø ×2Ò2ØØ%Øœ)Ô8Ø$1Ô$EØ#ð 3ñ ô ˆMð 2?Ð˜oÑ.Ð.åð A ð  Að  AÐq}ð  Að  Að  Añô ð õ ˜'Ð7Ð7Ð%6Ð7Ð7Ð7r   c                óø   — | j         €t          d| j        j        › d�¦  «        ‚d| j        _        | j                             |                      | j         | j        j	        d¬¦  «        ¦  «        | _
        | j
        S )a@  
        Returns the training [`~torch.utils.data.DataLoader`].

        Will use no sampler if `train_dataset` does not implement `__len__`, a random sampler (adapted to distributed
        training if necessary) otherwise.

        Subclass and override this method if you want to inject some custom behavior.
        Nz4Training requires specifying a train_dataset to the r—  Fro   ©rŒ  )rO   r›   r�   r—   ÚacceleratorÚeven_batchesÚpreparerŸ  rM   Útrain_batch_sizeÚ_train_dataloader)r�   s    r}   Úget_train_dataloaderz BaseTrainer.get_train_dataloader‹  s‚   € ð ÔÐ%ÝÐnÐTXÔTbÔTkÐnÐnÐnÑoÔoÐoð
 ).ˆÔÔ%Ø!%Ô!1×!9Ò!9Ø×"Ò" 4Ô#5°t´yÔ7QÐ`gÐ"ÑhÔhñ"
ô "
ˆÔð Ô%Ð%r   ú4str | Dataset | DatasetDict | IterableDataset | Nonec                óP  — |€:| j         €3| j        �t          g ¦  «        S t          d| j        j        › d�¦  «        ‚t          |t          ¦  «        r|nd}t          |t          ¦  «        p|du p|| j         u }|r"| j        j	        r|| j
        v r| j
        |         S t          |t          ¦  «        r| j         |         }n	|€| j         }d| j        _        | j                             |                      || j        j        d¬¦  «        ¦  «        }|r| j        j	        r
|| j
        |<   |S )aG  
        Returns the evaluation [`~torch.utils.data.DataLoader`].

        Subclass and override this method if you want to inject some custom behavior.

        Args:
            eval_dataset (`str` or `torch.utils.data.Dataset`, *optional*):
                If a `str`, will use `self.eval_dataset[eval_dataset]` as the evaluation dataset. If provided
                otherwise, will override `self.eval_dataset`. If it is a [`~datasets.Dataset`], columns not accepted
                by the `model.forward()` method are automatically removed. It must implement `__len__`.
        Nz6Evaluation requires specifying an eval_dataset to the r—  rp   Tr¡  )rQ   rT   r   r›   r�   r—   r„   rª   rM   rœ  r¿   r¢  r£  r¤  rŸ  Úeval_batch_size)r�   rQ   Údataloader_keyÚ	cacheablerB  s        r}   Úget_eval_dataloaderzBaseTrainer.get_eval_dataloader   sU  € ð Ð DÔ$5Ð$=àŒ~Ð)Ý! "‘~”~Ð%ÝÐpÐVZÔVdÔVmÐpÐpÐpÑqÔqÐqõ *4°LÅ#Ñ)FÔ)FÐR˜˜ÈFˆå˜|­SÑ1Ô1Ðn°\ÀTÐ5IÐnÈ\Ð]aÔ]nÐMnˆ	Øð 	:˜œÔ@ð 	:À^ÐW[ÔWmÐEmÐEmØÔ)¨.Ô9Ð9å�l¥CÑ(Ô(ð 	-ØÔ,¨\Ô:ˆLˆLØÐ!ØÔ,ˆLð
 )-ˆÔÔ%ØÔ%×-Ò-Ø×"Ò" <°´Ô1JÐY_Ð"Ñ`Ô`ñ
ô 
ˆ
ð ð 	@˜œÔ@ð 	@Ø5?ˆDÔ" >Ñ2àÐr   Útest_datasetc                óŽ   — d| j         _        | j                              |                      || j        j        d¬¦  «        ¦  «        S )aµ  
        Returns the test [`~torch.utils.data.DataLoader`].

        Subclass and override this method if you want to inject some custom behavior.

        Args:
            test_dataset (`torch.utils.data.Dataset`, *optional*):
                The test dataset to use. If it is a [`~datasets.Dataset`], columns not accepted by the
                `model.forward()` method are automatically removed. It must implement `__len__`.
        TÚtestr¡  )r¢  r£  r¤  rŸ  rM   rª  )r�   r®  s     r}   Úget_test_dataloaderzBaseTrainer.get_test_dataloaderÎ  sH   € ð )-ˆÔÔ%ØÔ×'Ò'Ø×"Ò" <°´Ô1JÐY_Ð"Ñ`Ô`ñ
ô 
ð 	
r   ri   c                óô  — |�|n| j         j        }t          j        |d¬¦  «         t                               d|› �¦  «         t          | j         d¦  «        r'| j                             || j         j	        ¬¦  «         n| j                             |¦  «         | j
        �| j
                             |¦  «         t          j        | j         t          j                             |t          ¦  «        ¦  «         d S )NTrI  zSaving model checkpoint to Úsave_safetensors)Úsafe_serialization)rM   ri   r¶   rT  r˜   r™   r¤   rK   Úsave_pretrainedr³  rH   rÝ   ÚsaverR  rS  r   )r�   ri   Ú
state_dicts      r}   Ú_savezBaseTrainer._saveá  sä   € à#-Ð#9�Z�Z¸t¼yÔ?Sˆ
Ý
Œ�J¨Ð.Ñ.Ô.Ð.Ý�ŠÐ>°*Ð>Ð>Ñ?Ô?Ð?õ �4”9Ð0Ñ1Ô1ð 	3ØŒJ×&Ò& zÀdÄiÔF`Ð&ÑaÔaÐaÐaàŒJ×&Ò& zÑ2Ô2Ð2ð Ô Ð,ØÔ!×1Ò1°*Ñ=Ô=Ð=õ 	Œ
�4”9�bœgŸlšl¨:Õ7IÑJÔJÑKÔKÐKÐKÐKr   Úcheckpoint_folderc                ó&  •— |                       ¦   «         �rY| j        j        t          j        k    �r>| j        j        s!| j        �| j                             ¦   «         �r|                      |¦  «        }t          j
        | j        j        d¬¦  «         t          j        |¦  «        D ]Ç}||v s*|                     d¦  «        s|                     d¦  «        rŒ1t          j                             ||¦  «        }t          j                             | j        j        |¦  «        }t          j                             |¦  «        rt#          j        ||d¬¦  «         Œ²t#          j        ||¦  «         ŒÈt)          ¦   «                              |¦  «         d S )NTrI  Ú	rng_stater  )Údirs_exist_ok)Úis_world_process_zerorM   Úhub_strategyr   ÚENDÚhub_always_pushÚpush_in_progressÚis_doneÚ_checkpoint_push_skip_namesr¶   rT  ri   Úlistdirr2  rR  rS  ÚisdirÚshutilÚcopytreer"  r°   Ú_push_from_checkpoint)r�   r¹  Ú
skip_namesrç   ÚsrcÚdstr�   s         €r}   rÈ  z!BaseTrainer._push_from_checkpointõ  sb  ø€ ð ×&Ò&Ñ(Ô(ñ	*à”	Ô&­+¬/Ò9Ñ9Ø”Ô*ð :Ø.2Ô.CÐ.KÈtÔOd×OlÒOlÑOnÔOnÑ.Kà×9Ò9Ð:KÑLÔLˆJÝŒK˜œ	Ô,°tÐ<Ñ<Ô<Ð<Ýœ
Ð#4Ñ5Ô5ð *ð *�Ø˜:Ð%Ð%¨¯ª¸Ñ)EÔ)EÐ%ÈÏÊÐYfÑIgÔIgÐ%ØÝ”g—l’lÐ#4°dÑ;Ô;�Ý”g—l’l 4¤9Ô#7¸Ñ>Ô>�Ý”7—=’= Ñ%Ô%ð *Ý”O C¨¸DÐAÑAÔAÐAÐAå”K  SÑ)Ô)Ð)Ð)å‰Œ×%Ò%Ð&7Ñ8Ô8Ð8Ð8Ð8r   úset[str]c                ól  — t           t          t          t          t          t
          t          t          t          t          t          t          h}t          ¦   «         r|t          t          t          hz  }t          t          fD ]µ}t           j                             ||¦  «        }t           j                             |¦  «        rtt)          |¦  «        5 }|                     t-          j        |¦  «                             di ¦  «                             ¦   «         ¦  «         d d d ¦  «         n# 1 swxY w Y   Œ¶|S )NÚ
weight_map)r   r   r   r   r   r   r#   r$   r(   r&   r'   r%   r)   r    r"   r!   r¶   rR  rS  ÚisfileÚopenrV  ÚjsonÚloadrw   rõ   )r�   r¹  ÚskipÚ
index_nameÚ
index_pathÚfs         r}   rÃ  z'BaseTrainer._checkpoint_push_skip_names  sD  € õ
 ÝÝÝÝÝÝÝ"ÝÝÝÝ#ð
ˆõ ÑÔð 	[ØÕ(Õ*>Õ@YÐZÑZˆDÝ-Õ/FÐGð 	Mð 	MˆJÝœŸšÐ&7¸ÑDÔDˆJÝŒw�~Š~˜jÑ)Ô)ð MÝ˜*Ñ%Ô%ð M¨Ø—K’K¥¤	¨!¡¤× 0Ò 0°¸rÑ BÔ B× IÒ IÑ KÔ KÑLÔLÐLðMð Mð Mñ Mô Mð Mð Mð Mð Mð Mð Møøøð Mð Mð Mð Møàˆs   ÃAD(Ä(D,	Ä/D,	Úcheckpoint_pathc                ó¤   — | j         j        } ||| j         j        ¬¦  «        }| j                              |                     ¦   «         ¦  «         d S )N)Útrust_remote_code)rK   r�   rÙ  Úload_state_dictr·  )r�   r×  r–   Úloaded_models       r}   ra  z!BaseTrainer._load_from_checkpoint(  sM   € Ø”jÔ*ˆØ"�{ ?ÀdÄjÔFbÐcÑcÔcˆØŒ
×"Ò" <×#:Ò#:Ñ#<Ô#<Ñ=Ô=Ð=Ð=Ð=r   úDatasetDict | Dataset | Nonec                óÖ   — t          |d¦  «        s|€|S |                      ||¬¦  «         |                      || j        | j        ¦  «        r|                      |¦  «        }d|_        |S )aE  
        Preprocess the dataset by optionally lazily adding a dataset name column, required for multi-dataset training
        with multiple losses or for dataset-specific router mappings.

        Args:
            dataset (DatasetDict | Dataset | None): The dataset to preprocess. If None, no preprocessing is done.
            dataset_name (str | None): The name of the dataset, used for multi-dataset training with multiple losses.

        Returns:
            DatasetDict | Dataset | None: The preprocessed dataset, perhaps with dataset names added as a lazy column.
        Ú#_sentence_transformers_preprocessedNr”   T)r¤   rk  Ú#should_dataset_name_column_be_addedrM   rR   Úadd_dataset_name_columnrÞ  )r�   rÂ   rŽ   s      r}   r¾   zBaseTrainer.preprocess_dataset-  s{   € õ �7ÐAÑBÔBð 	ÀgÀoØˆNð 	×"Ò" 7¸Ð"ÑFÔFÐFà×3Ò3°G¸T¼YÈÌ	ÑRÔRð 	<Ø×2Ò2°7Ñ;Ô;ˆGð 7;ˆÔ3àˆr   ú nn.Module | dict[str, nn.Module]c                ót  — t          |t          t          f¦  «        oœt          |t          ¦  «        p‡|j        ot          |j        t          ¦  «        pf|j        o_t          |j        t          ¦  «        oEt          t          t          |j                             ¦   «         ¦  «        ¦  «        t          ¦  «        S )a  
        We should add a dataset name column to the dataset, if the dataset is a DatasetDict, *and* one of:

        a. The loss is a dictionary, or
        b. The prompts contain a mapping of dataset names, or
        c. The router_mapping contains a mapping of dataset names.
        )	r„   rA   rC   r®   rÎ   rÍ   r¨   r©   rõ   )r�   rÂ   rM   rR   s       r}   rß  z/BaseTrainer.should_dataset_name_column_be_addedK  sž   € õ ˜'¥KÕ1DÐ#EÑFÔFð 
Ý�t�TÑ"Ô"ð Ø”Ð?¥¨D¬L½$Ñ!?Ô!?ðð Ô#ð OÝ˜tÔ2µDÑ9Ô9ðOå�t¥D¨Ô)<×)CÒ)CÑ)EÔ)EÑ$FÔ$FÑGÔGÍÑNÔNð	
r   ú=DatasetDict | IterableDatasetDict | Dataset | IterableDatasetc                ó  — t          |t          t          f¦  «        r6|                     ¦   «         D ]\  }}|                      ||¬¦  «        ||<   Œ |S |€|S t          |t
          ¦  «        r-|                     t          | j        fd|i|j	        ¤Ž¦  «         nlt          |t          ¦  «        rH|j        }|rt          d¦  «        |d<   |                     t          | j        |¬¦  «        d|¬¦  «        }nt          d¦  «        ‚|S )N)rÂ   rŽ   rŽ   rq   r”   T)Úbatchedr  z`Unsupported `dataset` type. Use a Dataset, DatasetDict, IterableDataset, or IterableDatasetDict.)r„   rC   rA   r­   rà  r@   Úset_transformr	   Úadd_dataset_name_transformÚ_format_kwargsrB   r  rD   Úmapr›   )r�   rÂ   rŽ   Úinner_datasetr  s        r}   rà  z#BaseTrainer.add_dataset_name_columnb  sb  € õ
 �gÕ 3µ[ÐAÑBÔBð 	Ø/6¯}ª}©¬ð ð Ñ+�˜mØ(,×(DÒ(DØ)Ø!-ð )Eñ )ô )�˜Ñ%Ð%ð ˆNð ÐØˆNõ �g�wÑ'Ô'ð 	Ø×!Ò!ÝØÔ3ðð à!-ðð Ô,ðð ñô ð ð õ ˜¥Ñ1Ô1ð 	àÔ'ˆHØð ;Ý+0°©?¬?�˜Ñ(à—k’kÝØÔ3Ø!-ðñ ô ð Ø!ð "ñ ô ˆGˆGõ Ørñô ð ð ˆr   Úbatchúdict[str, list[Any]]Ú	transformú=Callable[[dict[str, list[Any]]], dict[str, list[Any]]] | Nonec                óô   — |r || ¦  «        } | r)t          |                      ¦   «         ¦  «        d         r|€| S t          t          |                      ¦   «         ¦  «        d         ¦  «        }|g|z  | d<   | S )aÝ  A transform/map function that adds the dataset name to the batch.

        Args:
            batch (dict[str, list[Any]]): The batch of data, where each key is a column name and each value
                is a list of values.
            dataset_name (str | None, optional): The name of this dataset, only if there are multiple datasets
                that use a different loss. Defaults to None.
            transform (Callable[[dict[str, list[Any]]], dict[str, list[Any]]], optional): An optional transform
                function to apply on the batch before adding the dataset name. Defaults to None.

        Returns:
            dict[str, list[Any]]: The "just-in-time" transformed batch with the dataset name added.
        r   NrŽ   )r  rõ   r½   )rë  rŽ   rí  Úkwargsrm  s        r}   rç  z&BaseTrainer.add_dataset_name_transform’  s…   € ð, ð 	%Ø�I˜eÑ$Ô$ˆEð ð 	�D §¢¡¤Ñ0Ô0°Ô3ð 	°|Ð7KØˆLõ �˜eŸlšl™nœnÑ-Ô-¨aÔ0Ñ1Ô1ˆ
Ø!- °Ñ ;ˆˆnÑØˆr   ÚlanguageÚlicenseÚtagsústr | list[str] | NoneÚ
model_nameÚfinetuned_fromÚtasksÚdataset_tagsÚdataset_argsc
                óD  — |                       ¦   «         sd S |r| j        j                             |¦  «         |r| j        j                             |¦  «         |r| j        j                             |¦  «         | j                             | j        j        |¬¦  «         d S )N)rõ  )	r½  rK   r¡   Úset_languageÚset_licenseÚadd_tagsÚ_create_model_cardrM   ri   )r�   rñ  rò  ró  rõ  rö  r÷  rø  rÂ   rù  rð  s              r}   Úcreate_model_cardzBaseTrainer.create_model_card´  s¦   € ð ×)Ò)Ñ+Ô+ð 	ØˆFàð 	>ØŒJÔ&×3Ò3°HÑ=Ô=Ð=Øð 	<ØŒJÔ&×2Ò2°7Ñ;Ô;Ð;Øð 	6ØŒJÔ&×/Ò/°Ñ5Ô5Ð5àŒ
×%Ò% d¤iÔ&:ÀzÐ%ÑRÔRÐRÐRÐRr   útuple[Any, Any]c                ó  •‡‡‡— t          | j        t          ¦  «        r't          j        t          | j        ¦  «        ¦  «        }n| j        }t          ¦   «                              ||¦  «        \  }}|                      |¦  «        Šh d£t          | 
                    ¦   «         ¦  «        z  sSˆfd„|                     ¦   «         D ¦   «         | j        j        dœˆfd„|                     ¦   «         D ¦   «         ddœg|d<   |j                             ¦   «         D �]j\  Š}t          | 
                    ¦   «         ¦  «        h d£z  }|r|                     ¦   «         nd}ˆfd„|                     ¦   «         D ¦   «         Š‰r'||         D ]}	d|	v rˆfd	„|	d         D ¦   «         |	d<   Œnt#          d
‰› d�¦  «        ‚ˆfd„‰                     ¦   «         D ¦   «         }
ˆfd„‰                     ¦   «         D ¦   «         }|
rH||                              t'          |
                     ¦   «         ¦  «        || j        j        dœ¦  «         |r>||                              t'          |                     ¦   «         ¦  «        |ddœ¦  «         �Œl||fS )a5  
        We have to override the optimizer_grouped_parameters because the Trainer superclass bases it on the `model`
        itself, but the BaseModel losses can have weights that should be updated as well, e.g.
        SoftmaxLoss (see #2872).

        This method requires `transformers` >= 4.43.0.
        >   rK   ÚparamsÚoptimizer_dictc                ó0   •— g | ]\  }}|‰v ¯	|j         ¯|‘ŒS rŒ   ©Úrequires_grad©ry   ÚnÚpÚdecay_parameterss      €r}   rË   z<BaseTrainer.get_optimizer_cls_and_kwargs.<locals>.<listcomp>ä  s8   ø€ ð ð ð Ù"˜a ÈÐM]ÐH]ÐH]ÐbcÔbqÐH]˜ÐH]ÐH]ÐH]r   )r  Úweight_decayc                ó0   •— g | ]\  }}|‰v¯	|j         ¯|‘ŒS rŒ   r  r  s      €r}   rË   z<BaseTrainer.get_optimizer_cls_and_kwargs.<locals>.<listcomp>ê  s8   ø€ ð ð ð Ù"˜a ÈÐQaÐHaÐHaÐfgÔfuÐHa˜ÐHaÐHaÐHar   r
  r  c                óF   •— i | ]\  }}t          j        ‰|¦  «        ¯||“ŒS rŒ   )ÚreÚsearch)ry   r  r	  Úparameter_patterns      €r}   r~   z<BaseTrainer.get_optimizer_cls_and_kwargs.<locals>.<dictcomp>ø  s4   ø€ ÐqÐqÐq©¨¨1ÕQSÔQZÐ[lÐnoÑQpÔQpÐq˜q !ÐqÐqÐqr   r  c                óp   •‡— g | ]1Št          ˆfd „‰                     ¦   «         D ¦   «         ¦  «        ¯/‰‘Œ2S )c              3  ó    •K  — | ]}‰|uV — Œ	d S rƒ   rŒ   )ry   Úparamr	  s     €r}   r‡   zFBaseTrainer.get_optimizer_cls_and_kwargs.<locals>.<listcomp>.<genexpr>ÿ  s(   øè è € Ð=sÐ=sÐQV¸aÀu¸nÐ=sÐ=sÐ=sÐ=sÐ=sÐ=sr   )Úallrõ   )ry   r	  Úmatching_paramss    @€r}   rË   z<BaseTrainer.get_optimizer_cls_and_kwargs.<locals>.<listcomp>þ  sY   øø€ ð +ð +ð +Ø"#½#Ð=sÐ=sÐ=sÐ=sÐZi×ZpÒZpÑZrÔZrÐ=sÑ=sÔ=sÑ:sÔ:sð+Øð+ð +ð +r   z*No parameters found matching the pattern 'z^' in the model. Please check the pattern and ensure it matches some of the model's parameters.c                ó$   •— i | ]\  }}|‰v ¯	||“ŒS rŒ   rŒ   r  s      €r}   r~   z<BaseTrainer.get_optimizer_cls_and_kwargs.<locals>.<dictcomp>	  s+   ø€ Ð)lÐ)lÐ)l±4°1°aÐVWÐ[kÐVkÐVk¨!¨QÐVkÐVkÐVkr   c                ó$   •— i | ]\  }}|‰v¯	||“ŒS rŒ   rŒ   r  s      €r}   r~   z<BaseTrainer.get_optimizer_cls_and_kwargs.<locals>.<dictcomp>
  s+   ø€ Ð,sÐ,sÐ,s±d°a¸ÐYZÐbrÐYrÐYr¨Q°ÐYrÐYrÐYrr   )r  Úlrr  )r„   rR   r®   r   Ú
Sequentialr   r°   Úget_optimizer_cls_and_kwargsÚget_decay_parameter_namesrº   r»   Únamed_parametersrM   r  Úlearning_rate_mappingr­   rý   r›   r7  r  rõ   )r�   rM   rK   Ú
loss_modelÚoptimizer_clsÚoptimizer_kwargsÚlearning_rateÚoptimizer_param_keysÚoptimizer_param_keyÚgroupÚmatching_params_with_decayÚmatching_params_without_decayr
  r  r  r�   s               @@@€r}   r  z(BaseTrainer.get_optimizer_cls_and_kwargsÍ  sR  øøøø€ õ �d”i¥Ñ&Ô&ð 	#Ýœ¥{°4´9Ñ'=Ô'=Ñ>Ô>ˆJˆJàœˆJÝ*/©'¬'×*NÒ*NÈtÐU_Ñ*`Ô*`Ñ'ˆÐ'ð  ×9Ò9¸*ÑEÔEÐØ4Ð4Ð4µsÐ;K×;PÒ;PÑ;RÔ;RÑ7SÔ7SÑSð 	ðð ð ð Ø&0×&AÒ&AÑ&CÔ&Cðñ ô ð %)¤IÔ$:ð	ð ðð ð ð Ø&0×&AÒ&AÑ&CÔ&Cðñ ô ð %(ð	ð ð2ÐÐ-Ñ.ð  15Ô0J×0PÒ0PÑ0RÔ0Rð *	ñ *	Ñ,Ð˜}å#&Ð'7×'<Ò'<Ñ'>Ô'>Ñ#?Ô#?ÐBgÐBgÐBgÑ#gÐ Ø@TÐ"jÐ"6×":Ò":Ñ"<Ô"<Ð"<ÐZjÐð rÐqÐqÐq°
×0KÒ0KÑ0MÔ0MÐqÑqÔqˆOàð à-Ð.AÔBð ð �EØ 5Ð(Ð(ð+ð +ð +ð +Ø',¨X¤ð+ñ +ô +˜˜h™øðõ !ðeÐARð eð eð eñô ð ð *mÐ)lÐ)lÐ)l¸?×;PÒ;PÑ;RÔ;RÐ)lÑ)lÔ)lÐ&Ø,sÐ,sÐ,sÐ,s¸o×>SÒ>SÑ>UÔ>UÐ,sÑ,sÔ,sÐ)à)ð Ø Ð!4Ô5×<Ò<å"&Ð'A×'HÒ'HÑ'JÔ'JÑ"KÔ"KØ+Ø(,¬	Ô(>ðð ñô ð ð -ð Ø Ð!4Ô5×<Ò<å"&Ð'D×'KÒ'KÑ'MÔ'MÑ"NÔ"NØ+Ø(+ðð ñô ð ùð Ð.Ð.Ð.r   )NNNNNNNNNNNrJ   NN)rK   rL   rM   rN   rO   rP   rQ   rP   rR   rS   rT   rU   rV   rW   rH   rX   rY   rZ   r[   r\   r]   r^   r_   r`   ra   rb   rc   rd   re   rf   rƒ   )rK   r.   rM   r8   rH   rX   re   r*   )rÁ   rÒ   re   rf   )re   r.   )rR   rà   rK   r.   re   rà   )rR   rê   rK   r.   re   rà   )rK   r.   re   rà   )FN)rK   r.   rø   rù   rú   rt   re   rû   )rR   r  re   rf   )r  r  r  r  re   rf   )rø   rù   re   r)  )NNrp   )rQ   r<  r=  r>  r?  rª   re   r  )rB  r   rC  rª   rD  rE  r=  r>  r?  rª   re   r   )re   rf   )rÂ   r@   rŽ   rg  re   rf   )NNr   )rÂ   r@   rm  r«   rn  rt   ro  r>  rp  rq  rr  r«   re   rs  )Nr   )
rÂ   r   r‚  rƒ  rp  rq  rr  r„  re   r   )rÂ   r‹  rm  r«   rŒ  rª   re   r   )re   r   )rQ   r¨  re   r   )r®  r‹  re   r   )ri   rg  re   rf   )r¹  rª   re   rf   )r¹  rª   re   rÌ  )r×  rª   re   rf   )rÂ   rÜ  rŽ   rg  re   rÜ  )rÂ   rÜ  rM   r8   rR   rá  re   rt   )rÂ   rã  rŽ   rg  re   rÜ  )rë  rì  rŽ   rg  rí  rî  re   rì  )	NNNNNNNNN)rñ  rg  rò  rg  ró  rô  rõ  rg  rö  rg  r÷  rô  rø  rô  rÂ   rô  rù  rô  re   rf   )rM   r8   rK   rL   re   r   )1r—   Ú
__module__Ú__qualname__Ú__doc__r.   r–   r0   Úmodel_card_data_classr/   rÕ   r*   rÐ   r8   rš   r?   r±   r¥   rÀ   rœ   rß   r�   r   r¹   r  r   r&  rþ   rA  rM  rf  rk  r�  rŠ  rŸ  r§  r­  r±  r¸  rÈ  rÃ  ra  r¾   rß  rà  Ústaticmethodrç  rÿ  r  Ú__classcell__rÈ   s   @r}   rG   rG   L   sn  ø€ € € € € ð?ð ?ðB €KØ-ÐØ 5ÐØ*ÐØ/ÐàÐÐ!3Ð4Ñ4Ô4ð #'Ø-1Ø]aØ\`ð
 Ø@DØ15ð
 Ø59ØCGØ26ØVbØ^bØeið/v8ð v8ð v8ð v8ð v8ð v8ñ 5Ô4ðv8ð@ ð'
ð '
ð '
ð '
ð '
ðRmð mð mð mð&ð ð ð ð ð ð ð2ð ð ð ð ð ð ð ð. ðð ð ñ „^ðð  %Øð2ð 2ð 2ð 2ð 2ðh@ð @ð @ð @ð0'%ð '%ð '%ð '%ð '%ð '%ð '%ðR) ð ) ð ) ð ) ðZ CGØ(,Ø!'ð		Nð 	Nð 	Nð 	Nð 	Nð 	Nð 	Nð -1Ø(,Ø!'ð/ð /ð /ð /ð /ð /ð /ðbð ð ð ð"
ð 
ð 
ð 
ð 
ð" 15Ø,0Øð?lð ?lð ?lð ?lð ?lðJ -1Øð*[ð *[ð *[ð *[ð *[ðXV8ð V8ð V8ð V8ðp&ð &ð &ð &ð, TXð,ð ,ð ,ð ,ð ,ð\
ð 
ð 
ð 
ð&Lð Lð Lð Lð Lð(9ð 9ð 9ð 9ð 9ð 9ð0ð ð ð ð6>ð >ð >ð >ð X\ðð ð ð ð ð<
ð 
ð 
ð 
ð4 $(ð.ð .ð .ð .ð .ð` ð $(ØSWðð ð ð ñ „\ððF  $Ø"Ø'+Ø!%Ø%)Ø(,Ø/3Ø*.Ø/3ðSð Sð Sð Sð Sð4 FJðQ/ð Q/ð Q/ð Q/ð Q/ð Q/ð Q/ð Q/ð Q/ð Q/ð Q/r   rG   )hÚ
__future__r   rw  rÑ  rP  r¶   r  rÆ  Úabcr   r   Úcollectionsr   Úcollections.abcr   Ú
contextlibr   Ú	functoolsr	   Útypingr
   rÝ   r   Útorch.utils.datar   r   r   r   Útransformersr   r   r   r   Ú%transformers.feature_extraction_utilsr   Ú#transformers.image_processing_utilsr   Útransformers.integrationsr   Útransformers.processing_utilsr   Útransformers.trainerr   r   r   r   r   r   Útransformers.trainer_utilsr   r   Útransformers.utilsr    r!   r"   r#   r$   r%   r&   r'   r(   r)   Ú(sentence_transformers.base.data_collatorr*   Ú%sentence_transformers.base.evaluationr+   r,   rã   r.   Ú%sentence_transformers.base.model_cardr/   r0   Ú"sentence_transformers.base.modulesr1   Ú"sentence_transformers.base.samplerr2   r3   r4   r5   r6   r7   Ú(sentence_transformers.base.training_argsr8   r9   r:   Úsentence_transformers.utilr;   r<   r=   r>   Ú%sentence_transformers.util.decoratorsr?   Údatasetsr@   rA   rB   rC   rD   Ú	getLoggerr—   r˜   rE   ÚImportErrorrG   rŒ   r   r}   ú<module>rH     s)  ðØ "Ð "Ð "Ð "Ð "Ð "à €€€Ø €€€Ø €€€Ø 	€	€	€	Ø 	€	€	€	Ø €€€Ø #Ð #Ð #Ð #Ð #Ð #Ð #Ð #Ø #Ð #Ð #Ð #Ð #Ð #Ø $Ð $Ð $Ð $Ð $Ð $Ø "Ð "Ð "Ð "Ð "Ð "Ø Ð Ð Ð Ð Ð Ø Ð Ð Ð Ð Ð à €€€Ø Ð Ð Ð Ð Ð Ø SÐ SÐ SÐ SÐ SÐ SÐ SÐ SÐ SÐ SÐ SÐ SØ ZÐ ZÐ ZÐ ZÐ ZÐ ZÐ ZÐ ZÐ ZÐ ZÐ ZÐ ZØ HÐ HÐ HÐ HÐ HÐ HØ BÐ BÐ BÐ BÐ BÐ BØ 3Ð 3Ð 3Ð 3Ð 3Ð 3Ø 8Ð 8Ð 8Ð 8Ð 8Ð 8ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð CÐ BÐ BÐ BÐ BÐ BÐ BÐ Bðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð FÐ EÐ EÐ EÐ EÐ EØ TÐ TÐ TÐ TÐ TÐ TÐ TÐ TØ 6Ð 6Ð 6Ð 6Ð 6Ð 6Ø ZÐ ZÐ ZÐ ZÐ ZÐ ZÐ ZÐ ZØ 5Ð 5Ð 5Ð 5Ð 5Ð 5ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð uÐ tÐ tÐ tÐ tÐ tÐ tÐ tÐ tÐ tØ nÐ nÐ nÐ nÐ nÐ nÐ nÐ nÐ nÐ nÐ nÐ nØ CÐ CÐ CÐ CÐ CÐ CàÐÑÔð [ØZÐZÐZÐZÐZÐZÐZÐZÐZÐZÐZÐZÐZÐZà	ˆÔ	˜8Ñ	$Ô	$€ðØ9Ð9Ð9Ð9Ð9Ð9Ð9øØð ð ð Ø€O€O€OðøøøðR/ð R/ð R/ð R/ð R/�'˜3ñ R/ô R/ð R/ð R/ð R/s   Ä&D- Ä-D7Ä6D7