rhv``ddlmZddlZddlZddlmZmZddlZddlm Z ddlm Z ddl m Z mZmZddl mZddlmZdd lmZmZdd lmZdd lmZdd lmZdd lmZmZddl m!Z!ddl"m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)m*Z*e)r ddl+m,Z,m-Z-m.Z.m/Z/ej`e1Z2Gdde'Z3y)) annotationsN)AnyCallable)parse)nn)EvalPredictionPreTrainedTokenizerBaseTrainerCallback) __version__) WandbCallback)SentenceEvaluatorSequentialEvaluator)Router)(SpladeRegularizerWeightSchedulerCallback)SparseEncoderDataCollator)"SparseMultipleNegativesRankingLoss SpladeLoss)SparseEncoderModelCardCallback SparseEncoder)SparseEncoderTrainingArguments)SentenceTransformerTrainer)is_datasets_availableis_training_available)Dataset DatasetDictIterableDatasetValueceZdZdZ d d fd Zd dZd d fd ZddZ ddZ d dfd Z d dfd Z xZ S)SparseEncoderTraineru@ SparseEncoderTrainer is a simple but feature-complete training and eval loop for PyTorch based on the SentenceTransformerTrainer that based on 🤗 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.SparseEncoder`, *optional*): The model to train, evaluate or use for predictions. If not provided, a `model_init` must be passed. args (:class:`~sentence_transformers.sparse_encoder.training_args.SparseEncoderTrainingArguments`, *optional*): The arguments to tweak for training. Will default to a basic instance of :class:`~sentence_transformers.sparse_encoder.training_args.SparseEncoderTrainingArguments` 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.SparseEncoder`], :class:`torch.nn.Module`], Dict[str, Callable[[:class:`~sentence_transformers.SparseEncoder`]]]], *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.sparse_encoder.losses.SparseMultipleNegativesRankingLoss` 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`) c h 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[t\|d7i||j`dk(rd|_0iid"|_1d#|_2t|jfd$r|ji|jf_5|||tm|jnjpDcgc]}t |trc}r ttjvjyd%d&|.tjd't{|t}|(d)d*+}t |tPr|jIDcic]\}}||j||c}}|_@t7ddg||gD]\}}| t |tPst d,|d-t-|jt-|jz x}s^t d.|d/t|d0t|d1k(rd2nd3d4|d5 n|j|||_@|t |ts t|}||_F|j.|j||j*|j(d6|_G|j`.|j||j*|j(d6|_0|j|ycc}wcc}}wcc}wcc}}w)8NzTo train a SparseEncoder 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 `SparseEncoderTrainingArguments` passed, using `output_dir=z`.) output_dirzRPlease use `SparseEncoderTrainingArguments` 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 SparseEncoderTrainer. 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_metricsz4.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 `SparseEncoderTrainer`, or set `args.eval_strategy='no'` to skip evaluation.)r*r+Tinclude_prompt_lengths WANDB_PROJECTzsentence-transformersaRNo `loss` passed, using `sentence_transformers.sparse_encoder.losses.SpladeLoss` as a default option. with `SparseMultipleNegativesRankingLoss` as the default loss function.Be careful, we also set the `query_regularizer_weight` and `document_regularizer_weight`, but this are really sensitive parameters and should be tuned for your task.)r2g-C6 ?giUMu>)r2lossquery_regularizer_weightdocument_regularizer_weightz,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 ValueErrorr7call_model_initwarningto_dict hub_model_idmodel_card_datamodel_id set_model_idhasattrr%r rtokenizer(r)setr&rchildren __class__zipr column_namesnextiterstrintfloatr/itemsrgettypedictr parse_versiontransformers_version eval_strategysuperr__init__r6accum_loss_componentscan_return_lossr4_include_prompt_lengthr>anycallback_handlerr9r osenviron setdefaultrr prepare_lossr@keyssortedlenr r evaluatorr5preprocess_datasetadd_model_card_callback)selfr2r3r5r6r@rur4r%r7r8r9r:r;r#default_args_dictmodulerFdatasetsamplenaive_type_mappingkeyvalueexample_features super_kwargscallbackloss_fnmissingrXs /var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/sentence_transformers/sparse_encoder/trainer.pyrhzSparseEncoderTrainer.__init__dsM2%&@  <&J KKXYcXddfg h1ZHDD"@Aqr r =%",,,."#abb%M)DO  & NN' ;hOWWY   U%:%:%C%C  ! ! . .t/@/@ A   !<EOO]tAuI  5!NN#22 BI)UfBgI$=$= >mpmr M9IJv&**JJSWSfSf j&)'6):]L" $ 4%%'? @8<8S8S8UD   5   DDYDYDcDcd 8]3d e JJ ! !/3J K < KKx  7eD)-,0 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  $$%67EK"$Fe"ts<X/X#X)X.ct|}|j||j|j|j|j |j |y)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 :class:`~sentence_transformers.sparse_encoder.trainer.SparseEncoderTrainer` 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. )r2trainerN)r add_callback on_init_endr3statecontrolr2)rxrymodel_card_callbacks rrwz,SparseEncoderTrainer.add_model_card_callback8sL==NO -.'' 4::t||SWS]S]gk'lc$t||S)N)trial)rgrM)rxrrXs rrMz$SparseEncoderTrainer.call_model_initHsw&U&33rc ddlm}|jD]`\}}|dk(rt||r||_t|t j jsDt|||j||b|S)Nrrr2) sentence_transformersrnamed_childrenrKr2torchrModulesetattroverride_model_in_loss)rxr@r2rnamechilds rrz+SparseEncoderTrainer.override_model_in_lossKsl7..0 OKD%w:e]#C" E588??3dD$?$?u$MN  O  rcZt|tjjr|j |j }n!||j |j }|t|t nd}d}t|jjD]\}}t|ts|}n|rv||dkDro|&|jjj|}n!tjdt|}|jjjd||S)NFrCzSpladeLoss detected without SpladeRegularizerWeightSchedulerCallback. Adding default SpladeRegularizerWeightSchedulerCallback to gradually increase weight values from 0 to their maximum.)r@)rKrrrtodevicer enumeratermr9rpoprIrNinsert)rxr@r2is_splade_losssplade_scheduler_callback_indexidxrsplade_callbacks rrqz!SparseEncoderTrainer.prepare_lossUs  dEHHOO ,775<<(D;>>%,,/D9=9ID*5u*.'&t'<'<'F'FG MC($LM25/  >FJilmJm.:"&"7"7"A"A"E"EFe"fK #KPT"U  ! ! + + 2 21o F rc*t|||||S)a Computes the loss for the SparseEncoder 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 SparseEncoder losses do not return outputs. Args: model (SparseEncoder): The SparseEncoder 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. )r2inputsreturn_outputsnum_items_in_batch)rg compute_loss)rxr2rrrrXs rrz!SparseEncoderTrainer.compute_lossws&2w#~Zl$  rc&t|||S)a9 We have to override the optimizer_grouped_parameters because the Trainer superclass bases it on the `model` itself, but the SparseEncoder losses can have weights that should be updated as well, e.g. SoftmaxLoss (see #2872). This method requires `transformers` >= 4.43.0. )r3r2)rgget_optimizer_cls_and_kwargs)rxr3r2rXs rrz1SparseEncoderTrainer.get_optimizer_cls_and_kwargssw3U3KKr) NNNNNNNNNNN)NNN)r2SparseEncoder | Noner3z%SparseEncoderTrainingArguments | Noner51Dataset | DatasetDict | dict[str, Dataset] | Noner6rr@znn.Module | dict[str, nn.Module] | Callable[[SparseEncoder], torch.nn.Module] | dict[str, Callable[[SparseEncoder], torch.nn.Module]] | Noneruz2SentenceEvaluator | list[SentenceEvaluator] | Noner4z SparseEncoderDataCollator | Noner%z)PreTrainedTokenizerBase | Callable | Noner7z"Callable[[], SparseEncoder] | Noner8z'Callable[[EvalPrediction], dict] | Noner9zlist[TrainerCallback] | Noner:z?tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]r;z;Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | NonereturnNone)ryzdict[str, Any]rr)N)rr)r@torch.nn.Moduler2rrr)r@z?C9=CG26W hl/R8#R84R8I R8 H R8 R8FR88R8=R8 7!R8"A#R8$0%R8&T'R8.)d/R80 1R8hm 4 J    L %   .   <  <SW L2 L;O L  L Lrr )4 __future__rloggingrntypingrrrpackaging.versionrrdr transformersrr r r retransformers.integrationsr sentence_transformers.evaluationr rsentence_transformers.modelsr?sentence_transformers.sparse_encoder.callbacks.splade_callbacksr2sentence_transformers.sparse_encoder.data_collatorr+sentence_transformers.sparse_encoder.lossesrr/sentence_transformers.sparse_encoder.model_cardr2sentence_transformers.sparse_encoder.SparseEncoderr2sentence_transformers.sparse_encoder.training_argsrsentence_transformers.trainerrsentence_transformers.utilrrdatasetsrrrr getLoggerrrIr rGrrrss" 4QQ<3S/tXfZL]DSEE   8 $L5Lr