rhddlmZddlZddlZddlZddlZddlmZddlm Z ddl m Z ddl m Z mZmZddlZddlmZddlmZdd lmZmZmZmZdd lmZmZmZmZdd lmZ dd l!m"Z"dd l#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;ddlZ>m?Z?ddl@mAZAmBZBmCZCeBrddlDmEZEmFZFmGZGmHZHmIZIejeKZLe rddlMmNZN ddl#mOZOGddeZQy#eP$rdZOYwxYw)) annotationsN) OrderedDict) nullcontext)partial) TYPE_CHECKINGAnyCallable)parse)nn) BatchSampler ConcatDataset DataLoader RandomSampler)EvalPredictionPreTrainedTokenizerBaseTrainerTrainerCallback) __version__) DataCollator) WandbCallback)TRAINING_ARGS_NAME)EvalLoopOutput)SentenceTransformerDataCollator)SentenceEvaluatorSequentialEvaluator) CoSENTLoss)$SentenceTransformerModelCardCallback)PoolingRouter)DefaultBatchSamplerGroupByLabelBatchSamplerMultiDatasetDefaultBatchSamplerNoDuplicatesBatchSamplerProportionalBatchSamplerRoundRobinBatchSampler) BatchSamplersMultiDatasetBatchSamplers$SentenceTransformerTrainingArguments)disable_loggingis_datasets_availableis_training_available)Dataset DatasetDictIterableDatasetIterableDatasetDictValueSentenceTransformer)TrackioCallbackceZdZdZ d dfd Zd dZd!d"fd Zd#dZ d$dZ d% d&dZ d'd Z d!d(fd Z d)d Z d* d+fd Z d* d,fd Zd-dZd!d.dZ d/ d0dZ d1 d2dZd3dZd!d4dZd5dZdd6dZd7dZd8dZ d9 d:dZ d; d:dZ d! d d?dZ d! d@fd ZxZ S)ASentenceTransformerTraineru SentenceTransformerTrainer 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 `_ documentation for more information on the integrated callbacks and how to write your own callbacks. Args: model (:class:`~sentence_transformers.SentenceTransformer`, *optional*): The model to train, evaluate or use for predictions. If not provided, a `model_init` must be passed. args (:class:`~sentence_transformers.training_args.SentenceTransformerTrainingArguments`, *optional*): The arguments to tweak for training. Will default to a basic instance of :class:`~sentence_transformers.training_args.SentenceTransformerTrainingArguments` 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, see `Training Overview > Dataset Format <../../../docs/sentence_transformer/training_overview.html#dataset-format>`_. 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, see `Training Overview > Dataset Format <../../../docs/sentence_transformer/training_overview.html#dataset-format>`_. loss (Optional[Union[:class:`torch.nn.Module`, Dict[str, :class:`torch.nn.Module`], Callable[[:class:`~sentence_transformers.SentenceTransformer`], :class:`torch.nn.Module`], Dict[str, Callable[[:class:`~sentence_transformers.SentenceTransformer`]]]], *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. Will default to :class:`~sentence_transformers.losses.CoSENTLoss` if no ``loss`` is provided. evaluator (Union[:class:`~sentence_transformers.evaluation.SentenceEvaluator`, List[:class:`~sentence_transformers.evaluation.SentenceEvaluator`]], *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.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 [here](callback). If you want to remove one of the default callbacks used, use the [`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 core model. If using a transformers model, it will be a [`PreTrainedModel`] subclass. - **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 `torch.nn.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 `TrainingArguments.place_model_on_device` is overridden to return `False` . - **is_in_train** -- Whether or not a model is currently running `train` (e.g. when `evaluate` is called while in `train`) NNc $ ts td|(d}tjd|dt |}nt |ts t d|%| | |_|j}n)td| tjd| |_| tjd t d j}|jr;|jjs%|jj|j|2t|d r&t |j t"r |j }|t%|j&|j(|j*t|d rt-|j.n t- }t0|j3Dcgc]}|j4c}vr|j(s t dt7ddg||gD]\}}t |t8s|j:$t=t?|}t@dtBdtDdtFdi}|jIDcic]*\}}|tK|jMtO|d,}}}t d|d|d|d|d t |tPrt |tRs tS|}t |tPrt |tRs tS|}|jrdn|||||||nd| | | | | d }tUtVtUdk\r||d<n||d <|*|(|jXdk7rt d |jXd!t[|d4i||j^dk(rd|_/iid"|_0d#|_1t|jdd$r|jg|jd_4|||tk|jljnDcgc]}t |tpc}r trjtjwd%d&tx[tk|jljnDcgc]}t |txc}r trjtjwd'd&|*tjd(t{|j|}t |tPr|jIDcic]\}}||j||c}}|_@t7ddg||gD]\}}| t |tPst d)|d*t-|jt-|jz x}s^t d+|d,t|d-t|d.k(rd/nd0d1|d2 n|j|||_@|t |ts t|}||_F|j.|j||j*|j(d3|_G|j^.|j||j*|j(d3|_/|j|ycc}wcc}}wcc}wcc}wcc}}w)5NzTo train a SentenceTransformer 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_trainerzDNo `SentenceTransformerTrainingArguments` passed, using `output_dir=z`.) output_dirzXPlease use `SentenceTransformerTrainingArguments` imported from `sentence_transformers`.z<`Trainer` requires either a `model` or `model_init` argumentz`Trainer` requires either a `model` or `model_init` argument, but not both. `model_init` will overwrite your model when calling the `train` method.z`compute_metrics` is currently not compatible with the SentenceTransformerTrainer. Please use the `evaluator` argument instead for detailed evaluation metrics, or the `eval_dataset` argument for the evaluation loss.unused tokenizerall_special_ids) tokenize_fnrouter_mappingpromptsr<alYou 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'}.trainevalstringint64float32boolnullzThe 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_featuresdummy) modelargs data_collator train_dataset eval_dataset model_initcompute_metrics callbacks optimizerspreprocess_logits_for_metrics4.46.0processing_classnoz%You have set `args.eval_strategy` to z, but you didn't provide an `eval_dataset` or an `evaluator`. Either provide an `eval_dataset` or an `evaluator` to `SentenceTransformerTrainer`, or set `args.eval_strategy='no'` to skip evaluation.)r@rATinclude_prompt_lengths WANDB_PROJECTzsentence-transformersTRACKIO_PROJECTz@No `loss` passed, using `losses.CoSENTLoss` as a default option.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 occursz in `z_dataset` but not in `loss`.r?r> dataset_name)Jr+ RuntimeErrorloggerinfor( isinstance ValueErrorrMcall_model_initwarningto_dict hub_model_idmodel_card_datamodel_id set_model_idhasattrr;rrtokenizer>r?setr<rchildren __class__zipr. column_namesnextiterstrintfloatrEitemsr0gettypedictr- parse_versiontransformers_version eval_strategysuper__init__rLaccum_loss_componentscan_return_lossrJ_include_prompt_lengthrUanycallback_handlerrOrosenviron setdefaultr3rrH prepare_losslosskeyssortedlenrr evaluatorrKpreprocess_datasetadd_model_card_callback)selfrHrIrKrLrrrJr;rMrNrOrPrQr9default_args_dictmoduler\datasetsamplenaive_type_mappingkeyvalueexample_features super_kwargscallbackloss_fnmissingrns p/var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/sentence_transformers/trainer.pyr~z#SentenceTransformerTrainer.__init__s(%&@  <&J KK^_i^jjlm n7:NDD"FGj  =%",,,."#abb%M)DO  & NN' AHU]]_   U%:%:%C%C  ! ! . .t/@/@ A   !<EOO]tAuI  ;!NN#22 BI)UfBgI$=$= >mpmr M9IJv&**JJSWSfSf j&)'6):]L" $ 4%%'? @8<8S8S8UD   5   DDYDYDcDcd 8]3d e JJ ! !/3J K  &3CGCXCXCbCb cxZ/ 2 c,  JJ ! !"35L M < KKZ [djj)D dD !fjfpfpfrsMb\[bt'8'8%'HHsDI),gv->P\@])^ % g?!'40$F|nTvw"',,.1C 4DDD7D$TUaTbc&&,Wo%6fCLTUDUS[]<^^cdpcqrNO ))$6DI  I?P)Q+I6I"    )!%!8!8t||DDWDWfm"9"D     ( $ 7 7dll4CVCVek!8!D  $$%67oK$De dts<Y7/Y<Z"Z/Z ct|}|j||j|j|j|j |j |y)ai 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 :class:`~sentence_transformers.trainer.SentenceTransformerTrainer` class. 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 )rHtrainerN)r add_callback on_init_endrIstatecontrolrH)rrmodel_card_callbacks rrz2SentenceTransformerTrainer.add_model_card_callbackGsM CCTU -.'' 4::t||SWS]S]gk'lct||}t|ds|St|jt r|jj D]m\}}t|tjjs|||j|<@t|dsM|j|j||_o|St|jtjjs|j ||_|St|jdr!|j|j||_|S)N)trialrrH) r}rcrjrarryrvtorchr Moduleoverride_model_in_loss)rrrHrrrns rrcz*SentenceTransformerTrainer.call_model_init[s'e'4tV$L dii & $  1 N W!'588??;%,U^DIIcNWg. $ ; ;DIIu MDI  N DIIuxx7 %(DI  TYY (33DIIuEDI rc ddlm}|jD]`\}}|dk(rt||r||_t|t j jsDt|||j||b|S)Nrr1rH) sentence_transformersr2named_childrenrarHrr rsetattrr)rrrHr2namechilds rrz1SentenceTransformerTrainer.override_model_in_losstsm=..0 OKD%w:e5H#I" E588??3dD$?$?u$MN  O  rct|tjjr|j |j S||j |j SN)rarr rtodevice)rrrHs rrz'SentenceTransformerTrainer.prepare_loss~s@ dEHHOO ,775<<( (E{~~ell++rc|jdd}|j|\}}|j}t|tr|r||}||j k(r-t |dr!|j|k7r|j||}|||} t| trK|j| tjt| jj} |r| ifS| S)a Computes the loss for the SentenceTransformer 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 SentenceTransformers losses do not return outputs. Args: model (SentenceTransformer): The SentenceTransformer 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\NrH)popcollect_featuresrrary model_wrappedrjrHrtrack_loss_componentsrstacklistvaluessum) rrHinputsreturn_outputsnum_items_in_batchr\featureslabelsrrs r compute_lossz'SentenceTransformerTrainer.compute_losss2zz.$7 008&)) gt $l+G T'' ') &11'5AGx( dD !  & &t ,;;tDKKM23779D  8O rc.|jjrdnd}|jD]\}}|jjrt j |st j|rw||j|vr-t jd|j|j}n9|j||d|jjz|jz z }||j|vr||j||<|j|||z|j||< d|j|vr6t jdtj|j|d<|j|dxxdz cc<y)Nr@rAdtyperrXstepsr)rHtrainingrvrIlogging_nan_inf_filterrisnanisinfrtensorrrr global_step_globalstep_last_loggedrt)rr training_typerrs rrz0SentenceTransformerTrainer.track_loss_componentssi#'::#6#6F **, xJCyy//U[[5G5;;W\K]d88GG!LLEKK UE 66}EcJDJJ222T5Q5QQE$44]CCAF**=9#>AEA[A[\iAjknAorwAw**=9#> x $44]C CAFaWZchcocoApD & &} 5g > ""=1':a?:rcd}d|vrd}nd|vrd}|r|j}|j|j|}d|vr|jdj j }|j|dxxdzcc<|j D]\}}|dk(r |dk(r|d|n|}t|j |z j d||<tjd |j|j |j||<|t |5||St |5|S) Nrr@ eval_lossrArr_rr)copy_nested_gatherrrwritemrvroundrrrrr}log) rlogs start_timer accum_lossesrrrlog_keyrns rrzSentenceTransformerTrainer.logsK T>#M D "M 99;D..t/I/I-/XYL,&$((1557<<>**=9'BaGB"."4"4"6JCg~ :G6:Qq6WZG$)599;+>*D*D*F$JDMEJ\\5;;u||FD..}=cB   !7;tZ0 07;t$ $rc g}|D]}|jdr|dtd }nC|jdr|dtd }n"|jdr|dtd }ng|j|jDcic]&\}}|j |s|t|d|(c}}|j dd}||fScc}}w) aTurn 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_idsN input_ids_sentence_embeddingsentence_embedding _pixel_values pixel_valueslabel)endswithrappendrv startswithrw)rrrcolumnprefixrrrs rrz+SentenceTransformerTrainer.collect_featuress* tF|, 33{#3"34!67 <3';#<"<=1 63~#6"67 OOr:3[^[i[ijp[qSV/6r s tGT*ss C $C c|r>|j||jj|jjd}n |j}t ||||S)NrAr[)rrIr?r>rLr}evaluate)rrL ignore_keysmetric_key_prefixrns rrz#SentenceTransformerTrainer.evaluates] 22dii&7&7 H`H`ou3L ,,Lw k;LMMrct ||||||}|j|S|jr\t |j t rB|jdr1|ddt|j jdk(rd}n|S|jr tnttj5|jj }|7t"j$j'|d}t#j(|d|j|j*||j,j.|j,j0}dddt t sd |i}t|jD]0} | j|d r|j3| ||d | <2|j4j7||S#1swYxYw) N) dataloader descriptionprediction_loss_onlyrreval_rrATexist_ok) output_pathepochrrr)r}evaluation_loopr is_in_trainrarLryrrris_local_process_zerorr)loggingINFOrIr9rpathjoinmakedirsrHrrrrmetricsupdate) rrrrrroutputrevaluator_metricsrrns rrz*SentenceTransformerTrainer.evaluation_loop!s(!#!5#/ )  >> !M    4+<+->-C-C-E(Fq(II$*! "88:[]PWP\P\@] ))..K& ggll;?  K$7 $ 4::;K;KSWS]S]SiSi!/!   +T2!,.? @ )..01 ]C>>%6$7q"9:BSBWBWX[B\!%6$7q">? ] /0 %  s ?BGG$c Jtjd|jjd|jjd |jjx}rC|j ddd}|j jjt| |j|jjy#t$rY2wxYw#t$rB}tjd|jjdt|Yd}~yd}~wwxYw) NzLoading best model from z (score: z).-rXz#Could not load the best model from z . Error: )r_r`rbest_model_checkpoint best_metricrsplitrHrgset_best_model_steprt Exception_load_from_checkpointerrorrs)r checkpointstepexcs r_load_best_modelz+SentenceTransformerTrainer._load_best_modelRs .tzz/O/O.PPYZ^ZdZdZpZpYqqstu !ZZ===z=!((a04 **>>s4yI   & &tzz'G'G H       LL>tzz?_?_>``ijmnqjrist u  s+AC"%C CC D" 8DD"ct|tr,|jD]\}}|j||yt |j ddhzx}r"t d|r|dznddt|dy) Nr\ return_lossr\z/The following column names are invalid in your  rZz dataset: zH. Avoid using these column names, as they are reserved for internal use.)raryrvvalidate_column_namesrlrprbr)rrr\overlaps rrz0SentenceTransformerTrainer.validate_column_namescs gt $)0 O% g**7*N O '../=.2QQ Q7 QAXd,QTBTjlAmmvw{}DxEwFFZZ  RrcB|||||d}tj|jjrAt |jjt r|jj|fi|St |jjr|jj|fi|St|tr=|jjtjk7rtjdy|jjtjk(r t|fi|S|jjtjk(r t!|fi|S|jjtjk(rt t#||fi|Sy)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. ) batch_size drop_lastvalid_label_columns generatorseedBWhen using an IterableDataset, you cannot specify a batch sampler.N)r)inspectisclassrI batch_sampler issubclassr callablerar.r& BATCH_SAMPLERr_rd NO_DUPLICATESr#GROUP_BY_LABELr!r)rrrrrrrbatch_sampler_kwargss rget_batch_samplerz,SentenceTransformerTrainer.get_batch_samplerosS>%"#6"   ??49922 3 499CZCZ\o8p*499**7K6JK K DII++ ,*499**7K6JK K g /yy&&-*E*EEcd 99 " "m&A&A A+GL7KL L 99 " "m&B&B B+GL7KL L 99 " "m&A&A A&}W 'RkVjk k Brc,|||d}tj|jjrAt |jjt r|jj|fi|St |jjr|jj|fi|S|jjtjk(r tdd|i|S|jjtjk(r tdd|i|Sy)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 )batch_samplersrrrNr]) rr rImulti_dataset_batch_samplerr"r"r#r' ROUND_ROBINr% PROPORTIONALr$)rrr*rrmulti_batch_sampler_kwargss rget_multi_dataset_batch_samplerz:SentenceTransformerTrainer.get_multi_dataset_batch_samplers.-"& " ??499@@ Aj II 1 13RG 949988_D^_ _ DII99 :849988_D^_ _ 99 0 04M4Y4Y Y)X'X=WX X 99 0 04M4Z4Z Z+ZGZ?YZ Z [rc :|j td|j}|j}tj}|j j r%|j|j j ||j j|j j|j j|j jd}t|tr{|j|j j|j j d|j j"t$j&k7rt(j+dnot|t,r tdt|t.r|j1D]}t|tstd|j1Dcgc]J}|j3||j j|j j |j4|L}}t7|j1}|j9||||j j }||d <nit|t:rN|j3||j j|j j |j4|}||d <n td d |j<_|j<jAtC|fi||_"|jDScc}w) 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. zOTraining requires specifying a train_dataset to the SentenceTransformerTrainer. collate_fn num_workers pin_memorypersistent_workersprefetch_factorrrrcSentence Transformers is not compatible with IterableDatasetDict. Please use a DatasetDict instead.YSentence Transformers is not compatible with a DatasetDict containing an IterableDataset.rrrrrr*rrr!z^Unsupported `train_dataset` type. Use a Dataset, DatasetDict, or IterableDataset for training.F)#rKrbrJr GeneratorrIr manual_seeddataloader_num_workersdataloader_pin_memorydataloader_persistent_workersdataloader_prefetch_factorrar.rtrain_batch_sizedataloader_drop_lastr!r&r$r_rdr/r-rr(rr r/r, accelerator even_batchespreparer_train_dataloader)rrKrJrdataloader_paramsrr*r!s rget_train_dataloaderz/SentenceTransformerTrainer.get_train_dataloaders    %no o** ** OO% 99>>  ! !$)).. 1(99;;))99"&))"I"I#yyCC   m_ 5  $ $"&))"<"*>*@AM @@%-#YY^^ AM 2? o .  w / 229955))88$1$E$E# 3M2? o .p ).%!%!1!1!9!9*]:hVg:h!i%%%O sALc |.|j"|j tgStd||n |j}|j}t j }|jjr%|j|jj||jj|jj|jj|jjd}t|tr>|j!|jj"|jj$dnot|t&r tdt|t(r|j+D]}t|tstd|j+Dcgc]J}|j-||jj"|jj$|j.|L}}t1|j+}|j3||||jj}||d<nit|t4rN|j-||jj"|jj$|j.|}||d<n td d |j6_|j6j;t|fi|Scc}w) a Returns the evaluation [`~torch.utils.data.DataLoader`]. Subclass and override this method if you want to inject some custom behavior. Args: eval_dataset (`torch.utils.data.Dataset`, *optional*): If provided, 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__`. zQEvaluation requires specifying an eval_dataset to the SentenceTransformerTrainer.r1r7r8r9r:r;r!z_Unsupported `eval_dataset` type. Use a Dataset, DatasetDict, or IterableDataset for evaluation.T)rLrrrbrJrr<rIrr=r>r?r@rArar.reval_batch_sizerCr/r-rr(rr r/r,rDrErF)rrLrJrrHrr*r!s rget_eval_dataloaderz.SentenceTransformerTrainer.get_eval_dataloader3s  D$5$5$=~~)!"~%pq q'3'?|TEVEV ** OO% 99>>  ! !$)).. 1(99;;))99"&))"I"I#yyCC   lO 4  $ $"&))";";!%!?!?  &9 :u  k 2'..0 g7$s  ,224 &&#yy88"ii<<(5(I(I' ' N ))<)<)>?L @@$-#YY^^ AM 2? o .  g . 229944))88$1$E$E# 3M2? o .q )-%'' <(UCT(UVVO s/AK'c X|j}tj}|jjr%|j |jj||jj |jj|jj|jjd}t|tr>|j|jj|jjdnot|tr t!dt|t"r|j%D]}t|tst!d|j%Dcgc]J}|j'||jj|jj|j(|L}}t+|j%}|j-||||jj}||d<nit|t.rN|j'||jj|jj|j(|}||d<n t!dd |j0_|j0j5t7|fi|Scc}w) a Returns the training [`~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__`. r1r7r8r9r:r;r!z\Unsupported `test_dataset` type. Use a Dataset, DatasetDict, or IterableDataset for testing.T)rJrr<rIrr=r>r?r@rArar.rrKrCr/rbr-rr(rr r/r,rDrErFr)r test_datasetrJrrHrr*r!s rget_test_dataloaderz.SentenceTransformerTrainer.get_test_dataloaders_** OO% 99>>  ! !$)).. 1(99;;))99"&))"I"I#yyCC   lO 4  $ $"&))";";!%!?!?  &9 :u  k 2'..0 g7$s  ,224 &&#yy88"ii<<(5(I(I' ' N ))<)<)>?L @@$-#YY^^ AM 2? o .  g . 229944))88$1$E$E# 3M2? o .n )-%'' <(UCT(UVVO s/AJ'cP||n|jj}tj|dtj d||j j||jjtttdk\r(|jC|jj|n'|j|jj|tj|jtjj!|t"y)NTrzSaving model checkpoint to )safe_serializationrR)rIr9rrr_r`rHsave_pretrainedsave_safetensorsrzr{rSr;rsaverrr)rr9 state_dicts r_savez SentenceTransformerTrainer._saves#-#9Ztyy?S?S  J. 1*>? "":$))B\B\"] - .-2I I$$0%%55jA~~)..z:  499bggll:7IJKrc|jj}|||jj}|jj|j y)N)trust_remote_code)rHrnrXload_state_dictrU)rcheckpoint_path model_class loaded_models rr z0SentenceTransformerTrainer._load_from_checkpointsBjj** "?djjFbFbc  ""<#:#:#<=rcd|jD]!}t|ts|j cSy)a Return whether the prompt length should be passed to the model's forward method. True if the model does not include the prompt in the pooling layer. Can be overridden by the user if it's useful to include the prompt length. F)rHrarinclude_prompt)rrs rrz1SentenceTransformerTrainer._include_prompt_lengths5jj 1F&'*!0000 1rc^t|ds||S|j||||}d|_|S)aL Preprocess the dataset by optionally lazily adding a dataset name column, required for multi-dataset training with multiple losses, for dataset-specific prompts, or for dataset-specific router mappings. Args: dataset (DatasetDict | Dataset | None): The dataset to preprocess. If None, no preprocessing is done. prompts (dict[str, dict[str, str]] | dict[str, str] | str | None): Optional prompts to add to the dataset. If a string, it is used as a single prompt for all datasets, but it can also be a dictionary mapping dataset names to prompts, a dictionary mapping column names to prompts, or a nested dictionary mapping dataset names to column names to prompts. router_mapping (dict[str, dict[str, str]] | dict[str, str] | None): Optional router mapping to add to the dataset. Either a dictionary mapping of column names to :class:`~sentence_transformers.models.Router` routes or a nested dictionary mapping dataset names to column names to routes. 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_preprocessedrT)rjmaybe_add_dataset_name_columnr`)rrr?r>r\s rrz-SentenceTransformerTrainer.preprocess_dataset sC4 7A BgoN44Wg~dp4q7;3rcv|j|||t|ttfr|St|jt xs\|xrt|t xsF|xrBt|t xr0tt t|jt }|r|j|}|S)a Maybe add a dataset name column to the dataset, if 1. 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. Args: dataset (DatasetDict | Dataset | None): The dataset to add prompts or dataset names to. Returns: DatasetDict | Dataset | None: The dataset with prompts or dataset names added. r) rrar,r.rryrqrrradd_dataset_name_column)rrr?r>r\include_dataset_names rraz8SentenceTransformerTrainer.maybe_add_dataset_name_column0s. ""7"F ?j7O2LMN tyy$ ' 5Jw5 J~t4JtD)>)>)@$ABDI  227;Grct|ttfr0|jD]\}}|j ||||<|S||St|t r3|j t|jfd|i|j|St|trG|j}|rtd|d<|jt|j|d|}|Std)N)rr\r\rBrT)batchedrz`Unsupported `dataset` type. Use a Dataset, DatasetDict, IterableDataset, or IterableDatasetDict.)rar/r-rvrcr, set_transformradd_dataset_name_transform_format_kwargsr.rr0maprb)rrr\ inner_datasetrs rrcz2SentenceTransformerTrainer.add_dataset_name_columnZs g 3[A B/6}} + m(,(D(D)!-)E) %  N  N gw '  ! !33!-,, 6% 1''H+0?(kk33!-! "Gr rc |r||}|rt|jdr||Stt|jd}|g|z|d<|S)aA transform/map function that adds prompts or dataset names 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 prompts, etc. Defaults to None. Returns: dict[str, list[Any]]: The "just-in-time" transformed batch with prompts and/or dataset names added. rr\)rrr)batchr\ transformkwargsrs rrhz5SentenceTransformerTrainer.add_dataset_name_transformsd, e$ED03|7KLelln-a01 !- ;n rc  r|jsy|r%|jjj||r%|jjj ||r%|jjj ||jj |jj|y)N) model_name) is_world_process_zerorHrg set_language set_licenseadd_tags_create_model_cardrIr9) rlanguagelicensetagsrqfinetuned_fromtasks dataset_tagsr dataset_argsros rcreate_model_cardz,SentenceTransformerTrainer.create_model_cards))+   JJ & & 3 3H =  JJ & & 2 27 ;  JJ & & / / 5 %%dii&:&:z%Rrc t|jtr)tjt |j}n |j}t |||\}}|j|}hdt|jzs|jDcgc]\}}||vs |js|c}}|jjd|jDcgc]\}}||vs |js|c}}ddg|d<|jj!D]\} } t|jhdz} | r| j#nd} |jDcic]\}}t%j&| |s||!} }}| rJ|| D]A}d|vs|dDcgc]'t)fd| j+Ds&)c}|d<Cnt-d| d| j!Dcic] \}}||vs ||}}}| j!Dcic] \}}||vs ||}}}|rC|| j/t1|j+| |jjd |sg|| j/t1|j+| dd ||fScc}}wcc}}wcc}}wcc}wcc}}wcc}}w) a? We have to override the optimizer_grouped_parameters because the Trainer superclass bases it on the `model` itself, but the SentenceTransformer losses can have weights that should be updated as well, e.g. SoftmaxLoss (see #2872). This method requires `transformers` >= 4.43.0. >rHparamsoptimizer_dict)r weight_decayrrrc3&K|]}|u ywrr]).0paramps r zJSentenceTransformerTrainer.get_optimizer_cls_and_kwargs..s=sQVaun=ssz*No parameters found matching the pattern 'z^' in the model. Please check the pattern and ensure it matches some of the model's parameters.)rlrr)rarryr Sequentialrr}get_optimizer_cls_and_kwargsget_decay_parameter_namesrlrnamed_parameters requires_gradrIrlearning_rate_mappingrvrresearchallrrbrr)rrIrH loss_model optimizer_clsoptimizer_kwargsdecay_parametersnrparameter_pattern learning_rateoptimizer_param_keysoptimizer_param_keymatching_paramsgroupmatching_params_with_decaymatching_params_without_decayrns ` rrz7SentenceTransformerTrainer.get_optimizer_cls_and_kwargss dii &{499'=>JJ*/'*NtU_*`' ' 99*E4s;K;P;P;R7SS'1&A&A&C"aM]H]bcbqbq%)II$:$: '1&A&A&C"aQaHafgfufu%(  2 - . 150J0J0P0P0R*  , }#&'7'<'<'>#?Bg#g @T"6":":"M>S>S>U,sdaYZbrYrQT,s ),s) !45<<"&'A'H'H'J"K+(, (>(>- !45<<"&'D'K'K'M"N+(+I* X...u r +*m,ssT' K4 KK2 K? K KK K?'K$'K$ K)#K)> K/ K/) NNNNNNNNNNNr6N)rHSentenceTransformer | NonerIz+SentenceTransformerTrainingArguments | NonerKCDataset | DatasetDict | IterableDataset | dict[str, Dataset] | NonerLrrznn.Module | dict[str, nn.Module] | Callable[[SentenceTransformer], torch.nn.Module] | dict[str, Callable[[SentenceTransformer], torch.nn.Module]] | Nonerz2SentenceEvaluator | list[SentenceEvaluator] | NonerJzDataCollator | Noner;z)PreTrainedTokenizerBase | Callable | NonerMz(Callable[[], SentenceTransformer] | NonerNz'Callable[[EvalPrediction], dict] | NonerOzlist[TrainerCallback] | NonerPz?tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]rQz;Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | NonereturnNone)rzdict[str, Any]rrr)rr2)rtorch.nn.ModulerHr2rr)rzBCallable[[SentenceTransformer], torch.nn.Module] | torch.nn.ModulerHr2rr)FN)rHr2rdict[str, torch.Tensor | Any]rrErz2torch.Tensor | tuple[torch.Tensor, dict[str, Any]])rzdict[str, torch.Tensor]rr)rdict[str, float]rz float | Nonerr)rrrz9tuple[list[dict[str, torch.Tensor]], torch.Tensor | None])NNrA)rLz#Dataset | dict[str, Dataset] | Nonerlist[str] | Nonerrsrr) rrrrsrz bool | Nonerrrrsrr)rr)rr,r\ str | Nonerr)NNr)rr,rrtrrErrrtorch.Generator | NonerrtrzBatchSampler | None)Nr) rr r*zlist[BatchSampler]rrrz int | Nonerr )rr)rLz.Dataset | DatasetDict | IterableDataset | Nonerr)rNz'Dataset | DatasetDict | IterableDatasetrr)r9rrr)rZrsrr)rrE)NNNN) rDatasetDict | Dataset | Noner?z7dict[str, dict[str, str]] | dict[str, str] | str | Noner>z1dict[str, dict[str, str]] | dict[str, str] | Noner\rrr)NNN)rz=DatasetDict | IterableDatasetDict | Dataset | IterableDatasetr\rrr)rmdict[str, list[Any]]r\rrnz=Callable[[dict[str, list[Any]]], dict[str, list[Any]]] | Nonerr) NNNNNNNNN)rwrrxrrystr | list[str] | Nonerqrrzrr{rr|rrrr}rrr)rIr(rHrrztuple[Any, Any])!__name__ __module__ __qualname____doc__r~rrcrrrrrrrrrrr(r/rIrLrOrVr rrrarc staticmethodrhr~r __classcell__)rns@rr5r5;skCN-1<@]a\` HL-1?C?CCG26Vbei%D8)D8:D8[ D8 Z D8  D8FD8+D8=D8=D8AD8 0!D8"T#D8$(c%D8& 'D8Lm(2,P,#,  , % 2"2.2 2 < 2h@*%@! 3! B! J=A(,!' N9 N& N N  N$-1(,!' ///* / & /  / /b" "15,0<l<l<l <l . <l * <l<l <lD-1 *[*[+*[* *[  *[  *[XX&tZWxTWlL&> 15KOLP#' %-%I%J % ! % & %TLPLP#' (-(I(J ( ! ( & (Z$(.N.!. & .`$(SW# Q  F $"'+!%%)(,/3*./3SSS% S  S # S&S-S(S-S S4_cQ/8Q/A[Q/ Q/Q/rr5)R __future__rrrrr collectionsr contextlibr functoolsrtypingrrr rpackaging.versionr rzr torch.utils.datar r rr transformersrrrrrr{transformers.data.data_collatorrtransformers.integrationsrtransformers.trainerrtransformers.trainer_utilsr#sentence_transformers.data_collatorr sentence_transformers.evaluationrr'sentence_transformers.losses.CoSENTLossr sentence_transformers.model_cardrsentence_transformers.modelsrrsentence_transformers.samplerr r!r"r#r$r%#sentence_transformers.training_argsr&r'r(sentence_transformers.utilr)r*r+datasetsr,r-r.r/r0 getLoggerrr_)sentence_transformers.SentenceTransformerr2r3 ImportErrorr5r]rrrs" #"// 4SSZZ<8335OS>Q8 edZZ   8 $M9 [/[/ Os/DD  D