+
QV-j; h R t ^ RIt^ RIt^ RIt^ RIHt ^ RIt^ RIHt ^RI H
t
H t H t ^RI
Ht ^RIHt ]P" ! ]4 t] ! R R4 4 t ! R R
4 t] ! R R ]4 4 t ! R
R4 t ! R R]4 t ! R R]4 t ! R R]4 t ! R R]4 t ! R R]]4 t R# )zJ
Callbacks to use with the Trainer class and customize the training loop.
N) dataclass)tqdm)IntervalStrategy SaveStrategy
has_length)TrainingArguments)loggingc a ] tR t^"t o Rt^ t^ t^ tRtRt Rt
Rt ^ t ^ t
^ tRtRtRtRtRtRtRtRtRtRtR tV 3R lR lt]V 3R lR
l4 t R t R t V 3R
lt Rt V t!R# ) TrainerStatea
A class containing the [`Trainer`] inner state that will be saved along the model and optimizer when checkpointing
and passed to the [`TrainerCallback`].
In all this class, one step is to be understood as one update step. When using gradient accumulation, one update
step may require several forward and backward passes: if you use `gradient_accumulation_steps=n`, then one update
step requires going through *n* batches.
Args:
epoch (`float`, *optional*):
Only set during training, will represent the epoch the training is at (the decimal part being the
percentage of the current epoch completed).
global_step (`int`, *optional*, defaults to 0):
During training, represents the number of update steps completed.
max_steps (`int`, *optional*, defaults to 0):
The number of update steps to do during the current training.
logging_steps (`int`, *optional*, defaults to 500):
Log every X updates steps
eval_steps (`int`, *optional*):
Run an evaluation every X steps.
save_steps (`int`, *optional*, defaults to 500):
Save checkpoint every X updates steps.
train_batch_size (`int`, *optional*):
The batch size for the training dataloader. Only needed when
`auto_find_batch_size` has been used.
num_input_tokens_seen (`int`, *optional*, defaults to 0):
When tracking the inputs tokens, the number of tokens seen during training (number of input tokens, not the
number of prediction tokens).
total_flos (`float`, *optional*, defaults to 0):
The total number of floating operations done by the model since the beginning of training (stored as floats
to avoid overflow).
log_history (`list[dict[str, float]]`, *optional*):
The list of logs done since the beginning of training.
best_metric (`float`, *optional*):
When tracking the best model, the value of the best metric encountered so far.
best_global_step (`int`, *optional*):
When tracking the best model, the step at which the best metric was encountered.
Used for setting `best_model_checkpoint`.
best_model_checkpoint (`str`, *optional*):
When tracking the best model, the value of the name of the checkpoint for the best model encountered so
far.
is_local_process_zero (`bool`, *optional*, defaults to `True`):
Whether or not this process is the local (e.g., on one machine if training in a distributed fashion on
several machines) main process.
is_world_process_zero (`bool`, *optional*, defaults to `True`):
Whether or not this process is the global main process (when training in a distributed fashion on several
machines, this is only going to be `True` for one process).
is_hyper_param_search (`bool`, *optional*, defaults to `False`):
Whether we are in the process of a hyper parameter search using Trainer.hyperparameter_search. This will
impact the way data will be logged in TensorBoard.
stateful_callbacks (`list[StatefulTrainerCallback]`, *optional*):
Callbacks attached to the `Trainer` that should have their states be saved or restored.
Relevant callbacks should implement a `state` and `from_state` function.
i NTFc * V P f . V n V P f
/ V n R # \ V P \ 4 ' d R # / pV P F p\ V\ 4 ' g \ R\
V4 24 hVP P pW19 dO \ W, \ 4 ' g W, .W& W, P VP 4 4 K VP 4 W& K Wn R # )NzNAll callbacks passed to be saved must inherit `ExportableState`, but received ) log_historystateful_callbacks
isinstancedictExportableState TypeErrortype __class____name__listappendstate)selfr
callbacknames & n/Volumes/fast/ai/experiments/ui-tars-smoke/.venv/lib/python3.14/site-packages/transformers/trainer_callback.py
__post_init__TrainerState.__post_init__t s # !D " " *&(D #
//
6
6 "$ 3 3!(_>>#himnviwhxy ))22- &&8&>EE4F4L3M*0&,33HNN4DE/7~~/?&, 4 '9 # c < V ^8 d QhRS[ /# json_pathstr)format
__classdict__s "r __annotate__TrainerState.__annotate__ s ! !c !r c \ P ! \ P ! V 4 ^RR7 R, p\ VRRR7 ;_uu_ 4 pVP V4 RRR4 R# + ' g i R# ; i)zDSave the content of this instance in JSON format inside `json_path`.T)indent sort_keys
wutf-8encodingN)jsondumps dataclassesasdictopenwrite)r r" json_stringfs && r save_to_jsonTrainerState.save_to_json sQ jj!3!3D!9!tTW[[
)S7
3
3q
GGK 4
3
3
3s A'' A8 c < V ^8 d QhRS[ /# r r# )r% r& s "r r' r( s ' 's 'r c \ VRR7 ;_uu_ 4 pVP 4 pRRR4 V ! R/ \ P ! X4 B # + ' g i L,; i)z3Create an instance from the content of `json_path`.r. r/ N )r5 readr1 loads)clsr" r8 texts && r load_from_jsonTrainerState.load_from_json sC )g
.
.!668D /&TZZ%&& /
.s A A c R FI p\ W R24 pVf K V^8 d \ P ! W$, 4 p\ W R2V4 KK R# )zt
Calculates and stores the absolute value for logging,
eval, and save steps based on if it was a proportion
or not.
_stepsN)r evalsave)getattrmathceilsetattr)r args max_steps step_kind num_stepss &&& r
compute_stepsTrainerState.compute_steps sN 5I 6&:;I$ q= $ )*? @I 6 2I> 5r c & VP e/ VP e! VP VP 4 V n RV n Ve ^ RIHp V! V4 V n W n W0n VP 4 V n VP 4 V n R# )z9
Stores the initial training references needed in `self`
N) hp_params)
hp_name_trial
trial_name trial_paramstransformers.integrationsrS rM num_train_epochsis_local_process_zerois_world_process_zero)r trainerrM rY trialrS s &&&&& r init_training_references%TrainerState.init_training_references sx ?? &7>>+E &oognn =DO ; )% 0D " 0 %,%B%B%D"%,%B%B%D"r c < V ^8 d Qh/ S[ ;R& S[;R& S[;R& S[;R& S[;R& S[;R& S[R, ;R& S[;R & S[;R
& S[ ;R & S[S[S[S[ 3, , ;R & S[ R, ;R
& S[R, ;R& S[R, ;R& S[;R& S[;R& S[;R& S[R, ;R& S[S[S[S[ , S[, S[, 3, R, ;R& S[R, R, ;R& # )r! epoch global_steprM
logging_steps
eval_steps
save_stepsNtrain_batch_sizerY num_input_tokens_seen
total_flosr best_metricbest_global_stepbest_model_checkpointrZ r[ is_hyper_param_searchrV rW TrainerCallbackr
)floatintr r r$ bool)r% r& s "r r' r( " s{ z { | } ~ @ A B C D E F Dj'G H I J "K L M N d3:&'.O P $Q R Dj'S T :,U V &W X &Y Z '[ \ d
!] ^ sC%K# - 445<C_ ` ./$6=a r )rZ r[ r rM rY r
rV rW )"r
__module__ __qualname____firstlineno____doc__ra rb rM rc rd re rf rY rg rh r ri rj rk rZ r[ rl rV rW r
r r9 classmethodrB rP r^ __annotate_func____static_attributes____classdictcell__r& s @r r
r
" s 9v EKI MJJ#' !"J*.K $K#'(,"&"&"' !J?CL9=96! ! ' ' ?EO r r
c F a ] tR t^t o RtV 3R lR lt]R 4 tRtV t R# )r a
A class for objects that include the ability to have its state
be saved during `Trainer._save_checkpoint` and loaded back in during
`Trainer._load_from_checkpoint`.
These must implement a `state` function that gets called during the respective
Trainer function call. It should only include parameters and attributes needed to
recreate the state at a particular time, to avoid utilizing pickle/maintain standard
file IO writing.
Example:
```python
class EarlyStoppingCallback(TrainerCallback, ExportableState):
def __init__(self, early_stopping_patience: int = 1, early_stopping_threshold: Optional[float] = 0.0):
self.early_stopping_patience = early_stopping_patience
self.early_stopping_threshold = early_stopping_threshold
# early_stopping_patience_counter denotes the number of times validation metrics failed to improve.
self.early_stopping_patience_counter = 0
def state(self) -> dict:
return {
"args": {
"early_stopping_patience": self.early_stopping_patience,
"early_stopping_threshold": self.early_stopping_threshold,
},
"attributes": {
"early_stopping_patience_counter": self.early_stopping_patience_counter,
}
}
```c < V ^8 d QhRS[ /# r! returnr )r% r& s "r r' ExportableState.__annotate__ s b bt br c \ R 4 h)z ? @ !A B C r )r r r r r N)r rq rr rs rt r r r r r r r r r rv rw rx ry s @r r r sH 6 "' # K !O J*'
c r r c D a ] tR tRt o RtV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR
ltV 3R lR lt V 3R
lR lt
V 3R lR lt V 3R lR lt V 3R lR lt
V 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R! lR" ltR#tV tR$# )%rm i' a
A class for objects that will inspect the state of the training loop at some events and take some decisions. At
each of those events the following arguments are available:
Args:
args ([`TrainingArguments`]):
The training arguments used to instantiate the [`Trainer`].
state ([`TrainerState`]):
The current state of the [`Trainer`].
control ([`TrainerControl`]):
The object that is returned to the [`Trainer`] and can be used to make some decisions.
model ([`PreTrainedModel`] or `torch.nn.Module`):
The model being trained.
processing_class ([`PreTrainedTokenizer` or `BaseImageProcessor` or `ProcessorMixin` or `FeatureExtractionMixin`]):
The processing class used for encoding the data. Can be a tokenizer, a processor, an image processor or a feature extractor.
optimizer (`torch.optim.Optimizer`):
The optimizer used for the training steps.
lr_scheduler (`torch.optim.lr_scheduler.LambdaLR`):
The scheduler used for setting the learning rate.
train_dataloader (`torch.utils.data.DataLoader`, *optional*):
The current dataloader used for training.
eval_dataloader (`torch.utils.data.DataLoader`, *optional*):
The current dataloader used for evaluation.
metrics (`dict[str, float]`):
The metrics computed by the last evaluation phase.
Those are only accessible in the event `on_evaluate`.
logs (`dict[str, float]`):
The values to log.
Those are only accessible in the event `on_log`.
The `control` object is the only one that can be changed by the callback, in which case the event that changes it
should return the modified version.
The argument `args`, `state` and `control` are positionals for all events, all the others are grouped in `kwargs`.
You can unpack the ones you need in the signature of the event using them. As an example, see the code of the
simple [`~transformers.PrinterCallback`].
Example:
```python
class PrinterCallback(TrainerCallback):
def on_log(self, args, state, control, logs=None, **kwargs):
_ = logs.pop("total_flos", None)
if state.is_local_process_zero:
print(logs)
```c , < V ^8 d QhRS[ RS[RS[/# r! rL r controlr r
r )r% r& s "r r' TrainerCallback.__annotate__Z $ 1 , Q_ r c R# )zC
Event called at the end of the initialization of the [`Trainer`].
Nr= r rL r r kwargss &&&&,r on_init_endTrainerCallback.on_init_endZ r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r _ $ #4 \ Tb r c R# )z,
Event called at the beginning of training.
Nr= r s &&&&,r on_train_begin TrainerCallback.on_train_begin_ r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r d $ !2 < R` r c R# )z&
Event called at the end of training.
Nr= r s &&&&,r on_train_end TrainerCallback.on_train_endd r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r i r r c R# )z,
Event called at the beginning of an epoch.
Nr= r s &&&&,r on_epoch_begin TrainerCallback.on_epoch_begini r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r n r r c R# )z&
Event called at the end of an epoch.
Nr= r s &&&&,r on_epoch_end TrainerCallback.on_epoch_endn r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s s$ "3 L Sa r c R# )z
Event called at the beginning of a training step. If using gradient accumulation, one training step might take
several inputs.
Nr= r s &&&&,r
on_step_begin TrainerCallback.on_step_begins r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r y s$ *; L [i r c R# )zf
Event called before the optimizer step but after gradient clipping. Useful for monitoring gradients.
Nr= r s &&&&,r on_pre_optimizer_step%TrainerCallback.on_pre_optimizer_stepy r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r ~ s$ &7 We r c R# )zm
Event called after the optimizer step but before gradients are zeroed out. Useful for monitoring gradients.
Nr= r s &&&&,r on_optimizer_step!TrainerCallback.on_optimizer_step~ r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r r r c R# )zE
Event called at the end of an substep during gradient accumulation.
Nr= r s &&&&,r on_substep_end TrainerCallback.on_substep_end r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s$ 1 , Q_ r c R# )zz
Event called at the end of a training step. If using gradient accumulation, one training step might take
several inputs.
Nr= r s &&&&,r on_step_endTrainerCallback.on_step_end r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r r r c R# )z)
Event called after an evaluation phase.
Nr= r s &&&&,r on_evaluateTrainerCallback.on_evaluate r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s$ 0 P^ r c R# )z-
Event called after a successful prediction.
Nr= r rL r r metricsr s &&&&&,r
on_predictTrainerCallback.on_predict r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s# - l ^ r c R# )z'
Event called after a checkpoint save.
Nr= r s &&&&,r on_saveTrainerCallback.on_save r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s# , \ N r c R# )z+
Event called after logging the last logs.
Nr= r s &&&&,r on_logTrainerCallback.on_log r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s$ '8 Xf r c R# )z'
Event called after a prediction step.
Nr= r s &&&&,r on_prediction_step"TrainerCallback.on_prediction_step r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s$ "3 L Sa r c R# )z~
Event called before pushing the model to the hub, at the beginning of Trainer.push_to_hub and Trainer._push_from_checkpoint.
Nr= r s &&&&,r
on_push_begin TrainerCallback.on_push_begin r r r= N)r rq rr rs rt r r r r r r r r r r r r r r r r rw rx ry s @r rm rm ' s / b
r rm c r a ] tR tRt o RtR tR tR tR t] R 4 t
V 3R lR lt V 3R
lR lt V 3R lR
lt
V 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR ltV 3R lR! ltV 3R" lR# ltV 3R$ lR% ltV 3R& lR' ltR( tR)t V t R*# )+CallbackHandleri z>Internal class that just calls the list of callbacks in order.c . V n V F pV P V4 K W n W0n W@n WPn R V n R V n \ ;QJ d& R V P 4 F ' g K RM RM! R V P 4 4 ' g) \ P RV P , 4 R # R # )Nc 3 B " T F p\ V\ 4 x K R # 5iN)r DefaultFlowCallback.0cbs & r +CallbackHandler.__init__.. s P 2:b"566 s TFzThe Trainer will not work properly if you don't have a `DefaultFlowCallback` in its callbacks. You
should add one before training with `trainer.add_callback(DefaultFlowCallback). The current list ofcallbacks is
:) callbacks add_callbackmodelprocessing_class optimizer lr_schedulertrain_dataloadereval_dataloaderanyloggerwarning
callback_list)r r r r r r r s &&&&&& r __init__CallbackHandler.__init__ s B b !
0 " ( $ # sP PsssP PPP NN$ $$%
Qr c \ V\ 4 ' d V! 4 MTp\ V\ 4 ' d TM VP pY0P Uu. uF qDP NK up9 d2 \ P R V R2R, V P , 4 V P P V4 R# u upi )zYou are adding a zH to the callbacks of this Trainer, but there is already one. The currentzlist of callbacks is
:N)r r r r r r r r )r r r cb_classcs && r r CallbackHandler.add_callback s %h55XZ8 )(D 9 98x?Q?Q ^^<^ ^< < NN#H:-uv+,$$%
b!
=s B;c , \ V\ 4 ' dF V P F3 p\ W!4 ' g K V P P V4 Vu # R # V P F( pW!8X g K V P P V4 Vu # R # r r r r remover r r s && r pop_callback CallbackHandler.pop_callback sk h % %nn b++NN))"- I %
nn>NN))"- I %r c \ V\ 4 ' dE V P F2 p\ W!4 ' g K V P P V4 R # R # V P P V4 R # r r r s && r remove_callback CallbackHandler.remove_callback sQ h % %nn b++NN))"- %
NN ! !( +r c F R P R V P 4 4 # )r, c 3 L " T F qP P x K R # 5ir )r r r s & r r 0CallbackHandler.callback_list.. s H 2 .. s "$)joinr r s &r r CallbackHandler.callback_list s yyH HHHr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' CallbackHandler.__annotate__ ) N N 1 N, NQ_ Nr c , V P ! R WV3/ VB # )r
call_eventr s &&&&,r r CallbackHandler.on_init_end }d7MfMMr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r ) Q Q#4 Q\ QTb Qr c : R Vn V P ! RWV3/ VB # )Fr )r r r s &&&&,r r CallbackHandler.on_train_begin s# ',$ /gPPPr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r ) O O!2 O< OR` Or c , V P ! R WV3/ VB # )r r r s &&&&,r r CallbackHandler.on_train_end ~tGNvNNr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r r" r c : R Vn V P ! RWV3/ VB # )Fr )r r r s &&&&,r r CallbackHandler.on_epoch_begin s# $)! /gPPPr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r r& r c , V P ! R WV3/ VB # )r r r s &&&&,r r CallbackHandler.on_epoch_end r) r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s) P P"3 PL PSa Pr c V R Vn R Vn R Vn V P ! RWV3/ VB # )Fr )r r r r r s &&&&,r r CallbackHandler.on_step_begin s2 ""' #WOOOr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s) X X*; XL X[i Xr c , V P ! R WV3/ VB # )r r r s &&&&,r r %CallbackHandler.on_pre_optimizer_step s 6WWPVWWr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s) T T&7 T TWe Tr c , V P ! R WV3/ VB # )r r r s &&&&,r r !CallbackHandler.on_optimizer_step s 2DSFSSr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s) Q Q#4 Q\ QTb Qr c , V P ! R WV3/ VB # )r r r s &&&&,r r CallbackHandler.on_substep_end s /gPPPr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r r r c , V P ! R WV3/ VB # )r r r s &&&&,r r CallbackHandler.on_step_end r r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r
s) _ _ 1 _, _Q_ _r c > R Vn V P ! RWV3RV/VB # )Fr r )r r r s &&&&&,r r CallbackHandler.on_evaluate
s( "' }d7^G^W]^^r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s) ^ ^ 0 ^ ^P^ ^r c 0 V P ! R WV3RV/VB # )r r r r s &&&&&,r r CallbackHandler.on_predict s |T']7]V\]]r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s( J J - Jl J^ Jr c : R Vn V P ! RWV3/ VB # )Fr )r r r s &&&&,r r CallbackHandler.on_save s" #y$wI&IIr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s( T T, T\ TN Tr c > R Vn V P ! RWV3RV/VB # )Fr logs)r r )r rL r r rJ r s &&&&&,r r CallbackHandler.on_log s' "xgSDSFSSr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s) U U'8 U UXf Ur c , V P ! R WV3/ VB # )r r r s &&&&,r r "CallbackHandler.on_prediction_step s 3T'TVTTr c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' r s) P P"3 PL PSa Pr c , V P ! R WV3/ VB # )r r r s &&&&,r r CallbackHandler.on_push_begin s WOOOr c V P Fg p\ Wa4 ! VVV3R V P RV P RV P RV P
RV P RV P /VB pVf Ke TpKi V# )r r r r r r )r rH r r r r r r )r eventrL r r r r results &&&&&, r r CallbackHandler.call_event s H X- jj
"&!6!6 ..
" . . "&!6!6 !% 4 4 F ! ' r )r r r r r r r N) r rq rr rs rt r r r r propertyr r r r r r r r r r r r r r r r r r rw rx ry s @r r r s H& "
, I IN NQ QO OQ QO OP P X XT TQ QN N_ _^ ^J JT TU UP P r r c H a ] tR tRt o RtV 3R lR ltV 3R lR ltRtV tR# ) r i3 zp
A [`TrainerCallback`] that handles the default flow of the training loop for logs, evaluation and checkpoints.
c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' DefaultFlowCallback.__annotate__8 s$ & & 1 &, &Q_ &r c VP ^8X d VP ' d RVn VP \ P
8X d* VP VP , ^ 8X d RVn VP \ P
8X dE VP VP , ^ 8X d# VP VP 8: d RVn
VP \ P
8X d; VP ^ 8 d* VP VP , ^ 8X d RVn VP VP 8 d RVn VP \ P
8X dE VP VP , ^ 8w d# VP VP 8: d RVn
VP \ P
8X d RVn V# ) T)rb logging_first_stepr logging_strategyr STEPSrc
eval_strategyrd
eval_delayr
save_strategyr re r rM r r s &&&&,r r DefaultFlowCallback.on_step_end8 sp !d&=&=&=!%G $4$:$: :u?P?PSXSfSf?fjk?k!%G
"2"8"8 8!!E$4$4495#4#44&*G #
,"4"4 4 1$!!E$4$449"&G /+/G ( ""&6&<&<<%%(8(88A=OOu'8'88*.'!!\%7%77&*#r c , < V ^8 d QhRS[ RS[RS[/# r r )r% r& s "r r' rY ` s$
!2
<
R`
r c VP \ P 8X d R Vn VP \ P 8X d# VP
VP 8: d R Vn VP \ P 8X d R Vn
V# )T) r] r EPOCHr r_ r` ra r ra r r r s &&&&,r r DefaultFlowCallback.on_epoch_end` sp $4$:$: :!%G !1!7!7 7DOOu{{ z/. Consider increasing `max_str_len` if needed.].4grh )
r[ rm r r r$ rz rj rn popr6 )
r rL r r rJ r shallow_logsr r _s
&&&&&, r r ProgressCallback.on_log s & & &4+<+<+H L
a%%#a&43C3C*C?Axs4K[K[J\ ]H H !O 5)))*3LO&'O % t4A # #C $5 6! ,I &r c p VP ' d$ V P P 4 R V n R # R # r )r[ rm r~ r s &&&&,r r ProgressCallback.on_train_end s- & & & # # % $D 'r )rs rj rn rm )d r )r rq rr rs rt r r r r r r r r rw rx ry s @r rh rh p s<
' '
2
*' ' 7&% %r rh c . a ] tR tRt o RtRR ltRtV tR# )PrinterCallbacki z7
A bare [`TrainerCallback`] that just prints the logs.
Nc VP R R4 pVP ' dP Ve? VP 4 UUu/ uF" w rxT\ V\ 4 ' d VR
MTbK$ ppp\ V4 R# R# u uppi )rh Nr )r rZ r r rn print) r rL r r rJ r r r r s &&&&&, r r PrinterCallback.on_log sk HH\4 ( & & & SWS]S]S_`S_41*Q*>*>qgAES_` $K '`s (A6r= r )r rq rr rs rt r rw rx ry s @r r r s r r c ^ a ] tR tRt o RtR V 3R lR lltR tR tR tV 3R lR lt R
t
V t R # )
EarlyStoppingCallbacki a
A [`TrainerCallback`] that handles early stopping.
Args:
early_stopping_patience (`int`):
Use with `metric_for_best_model` to stop training when the specified metric worsens for
`early_stopping_patience` evaluation calls.
early_stopping_threshold(`float`, *optional*):
Use with TrainingArguments `metric_for_best_model` and `early_stopping_patience` to denote how much the
specified metric must improve to satisfy early stopping conditions. `
This callback depends on [`TrainingArguments`] argument *load_best_model_at_end* functionality to set best_metric
in [`TrainerState`]. Note that if the [`TrainingArguments`] argument *save_steps* differs from *eval_steps*, the
early stopping will not occur until the next save step.
c 4 < V ^8 d QhRS[ RS[R, /# )r! early_stopping_patienceearly_stopping_thresholdN)ro rn )r% r& s "r r' "EarlyStoppingCallback.__annotate__ s" 1 1 1SX[_S_ 1r c , Wn W n ^ V n R# ) Nr r early_stopping_patience_counter)r r r s &&&r r EarlyStoppingCallback.__init__ s '>$(@%/0,r c N VP ' d \ P M\ P pVP eC V! WBP 4 ' d4 \ WBP ,
4 V P 8 d
^ V n R # V ;P ^,
un R # r )greater_is_betternpgreaterlessri absr r )r rL r r metric_valueoperators &&&&& r check_metric_value(EarlyStoppingCallback.check_metric_value sn !%!7!7!72::RWW $ \#4#4 5 5L#4#4458U8UU34D 0 0 0A 5 0r c VP ' g \ P R 4 VP f Q R4 hVP \
P 8w g Q R4 hR# )zUsing EarlyStoppingCallback without load_best_model_at_end=True. Once training is finished, the best model will not be loaded automatically.NzBEarlyStoppingCallback requires metric_for_best_model to be definedzAEarlyStoppingCallback requires IntervalStrategy of steps or epoch)load_best_model_at_endr r metric_for_best_modelr_ r NOr s &&&&,r r $EarlyStoppingCallback.on_train_begin se *** NN^
))5
P
5 !!%5%8%88
O
8r c " VP pVP R 4 ' g R V 2pVP V4 pVf \ P RV R24 R# V P WW74 V P V P 8 d
RVn R# R# )eval_Nz@early stopping required metric_for_best_model, but did not find z so early stopping is disabledT) r
startswithgetr r r r r r )r rL r r r r metric_to_checkr s &&&&&, r r !EarlyStoppingCallback.on_evaluate s 44 ))'22 %o%6 7O {{?3 NNRSbRc d
WC / /43O3O O+/G ( Pr c < V ^8 d QhRS[ /# r| r~ )r% r& s "r r' r s
t
r c V R RV P RV P /RRV P //# )rL r r r r r r s &r r EarlyStoppingCallback.state s? )4+G+G*D,I,I
143W3W
r )r r r N)r[ g ) r rq rr rs rt r r r r r rw rx ry s @r r r s- 1 1 6
0"
r r ) rt r3 r1 rI r numpyr tqdm.autor
trainer_utilsr r r
training_argsr utilsr
get_loggerr r r
r r rm r r rh r r r= r r r s ! E E ,
H % WE WE WEt) )X :
_ :
:
zC C LCo CL:/ :zG% G%T
o
I
O_ I
r