6bi5SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK J s J r SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SS KJr SS KJr SS KJr SS KJr SS KJ r SSK!J"r" SSK#J$r% SSK&J'r' SSK(J)r) SSK*J+r+ SSK,r,SSSSSSS\"R\4Sjr/SSSSSS\"R\4Sjr0Sr1SLSjr2\)"S5"SS55r3\)"S5"SS55r4\)"S 5"S!S"\455r5\)"S#5"S$S%\455r6\)"S&5"S'S(\455r7\)"S)5"S*S+\455r8\)"S,5"S-S.\455r9\)"S//S09"S1S2\455r:\)"S3/S09\'Rv"S35"S4S5\:555r<\)"S65"S7S8\455r=\)"S95"S:S;\455r>\)"S<5"S=S>\455r?SMS?jr@\)"S@/S09"SASB\4\R55rB\)"SC5"SDSE\455rC\)"SF5"SGSH\455rD\)"SI5"SJSK\455rEg!\-a Sr,GNf=f)NzDCallbacks: utilities called at certain points during model training.N)backend)distributed_file_utils)worker_training_state) optimizer)learning_rate_schedule) generic_utils)io_utils)tf_utils) version_utils)Sequence)Progbar)ModeKeys) tf_logging) deprecation) keras_export) doc_controlsFstepsc [U[5(aU$U(d/nU [R:XaU[ 5Ul[ 5/U=(d /-UR /-nU(aUR[U55 [U5n UR5n U RU 5 [U UUUUUUUU S9 SU Rl U $)aConfigures callbacks for use in various training loops. Args: callbacks: List of Callbacks. model: Model being trained. do_validation: Whether or not validation loop will be run. batch_size: Number of samples per batch. epochs: Number of epoch to train. steps_per_epoch: Number of batches to run per training epoch. samples: Number of training samples. verbose: int, 0 or 1. TF-Keras logging verbosity to pass to ProgbarLogger. count_mode: One of 'steps' or 'samples'. Per-batch or per-sample count. mode: String. One of ModeKeys.TRAIN, ModeKeys.TEST, or ModeKeys.PREDICT. Which loop mode to configure callbacks for. Returns: Instance of CallbackList used to control all Callbacks. ) do_validation batch_sizeepochssteps_per_epochsamplesverbosemodeF) isinstance CallbackListrTRAINHistoryhistory BaseLoggerappend ProgbarLogger_get_callback_model set_modelset_callback_parametersmodel stop_training) callbacksr(rrrrrr count_moder callback_listcallback_models P/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/callbacks.pyconfigure_callbacksr/9s@)\**   x~~  \Nio26%--H    ]:6 7 +M..0NN+ #'  ).M% c Sn UH=n [U [[45(dM U (d URn U SSU lM? /n U[ R :waHU (d URn [R"U 5n U(aXV s/sHn SU -PM sn - n UUUUUUU S.n URU 5 gs sn f)a<Sets callback parameters. Args: callback_list: CallbackList instance. model: Model being trained. do_validation: Whether or not validation loop will be run. batch_size: Number of samples per batch. epochs: Number of epoch to train. steps_per_epoch: Number of batches to run per training epoch. samples: Number of training samples. verbose: int, 0 or 1. TF-Keras logging verbosity to pass to ProgbarLogger. mode: String. One of ModeKeys.TRAIN, ModeKeys.TEST, or ModeKeys.PREDICT. Which loop mode to configure callbacks for. Nrval_)rrrrrrmetrics) rr"r$ metrics_namesstateful_metricsrPREDICTcopy set_params)r,r(rrrrrrr metric_namescbkcallback_metricsncallback_paramss r.r'r'{s4L cJ 6 7 7$22 #/#3C  x ..L99\2  \ B\!\ B B   &#O_-!CsCc[US5=(dj [US5=(dW [U[[RR R R[R R45$)z5Checks if data is a generator, Sequence, or Iterator.__next__next)hasattrrr tfcompatv1dataIterator)rEs r._is_generator_likerGsY j! 4   8RYY\\..779I9IJ r0cURnU[R[R1;a#U(a[ XR5H upgXqXF-'M U$X!S'U$)4Computes logs for sending to `on_batch_end` methods.outputs)r4rrTESTzip)r(logsrJrprefixr9labeloutputs r. make_logsrQsT&&L  ..< 7ME#) 8 K"Y Kr0zkeras.callbacks.CallbackListc*\rSrSrSrS$SjrSrS%SjrSrSr S r S&S jr S r S r S rSrSrS&SjrS&SjrS&SjrS&SjrS&SjrS&SjrS&SjrS&SjrS&SjrS&SjrS&SjrS&SjrS&SjrS&SjrS&SjrS&Sjr S r!S!r"S'S"jr#S#r$g)(rz*Container abstracting a list of callbacks.Nc U(a[RRU5O/UlUR X#5 U(aUR U5 U(aUR U5 [SUR55Ul[SUR55Ul [SUR55Ul [SUR55Ul [SUR55Ul UR5 [SUR55UlSUl0UlSUl/Ulg) aContainer for `Callback` instances. This object wraps a list of `Callback` instances, making it possible to call them all at once via a single endpoint (e.g. `callback_list.on_epoch_end(...)`). Args: callbacks: List of `Callback` instances. add_history: Whether a `History` callback should be added, if one does not already exist in the `callbacks` list. add_progbar: Whether a `ProgbarLogger` callback should be added, if one does not already exist in the `callbacks` list. model: The `Model` these callbacks are used with. **params: If provided, parameters will be passed to each `Callback` via `Callback.set_params`. c3<# UHn[USS5v M g7f_supports_tf_logsFN)getattr.0cbs r. (CallbackList.__init__..s % >LGB+U 3 3nsc3# UHSnUR5(d,UR5(dUR5(dMD[USS5v MU g7frV)_implements_train_batch_hooks_implements_test_batch_hooks_implements_predict_batch_hooksrXrYs r.r\r]sP0 $//11..00113 4GB+U 3 3$s AA Ac3@# UHoR5v M g7fN)r_rYs r.r\r]s2 9G2 , , . .c3@# UHoR5v M g7frc)r`rYs r.r\r]s1 8F" + + - -rdc3@# UHoR5v M g7frc)rarYs r.r\r]s4 ;IR . . 0 0>rdc3b# UH%oRR[5;v M' g7frc) __class____name__globals)rZr:s r.r\r]s"! ?MMM " "') 3~s-/N)rBnestflattenr*_add_default_callbacksr&r8allrW_batch_hooks_support_tf_logsany_should_call_train_batch_hooks_should_call_test_batch_hooks _should_call_predict_batch_hooks$_disallow_batch_hooks_in_ps_strategy _check_timing_num_batches_for_timing_check _hook_times_batch_start_time _batch_times)selfr* add_history add_progbarr(paramss r.__init__CallbackList.__init__s908A3b ##K=  NN5 !  OOF #"%% >Bnn% " -00 nn0 - )/22 9=2 / +.11 8<1 . *144 ;?>>4 1 - 113 !! ?C~~!  ./*!%r0cSUlSUlURH=n[U[5(aX0lM [U[ 5(dM7X0lM? URc;U(a4[ 5UlURR UR5 URc<U(a4[ SS9UlURR UR5 ggg)z)Adds `Callback`s that are always present.Nr)r+)_progbar_historyr*rr$r r#)r{r|r}r[s r.rn#CallbackList._add_default_callbackss  ..B"m,, " B(( " ! == [#IDM NN ! !$-- 0 == [)W=DM NN ! !$-- 0&1 r0cUc0$UR(aU$U(aUR(aU$[R"U5$)z?Turns tensors into numpy arrays or Python scalars if necessary.)rWrpr sync_to_numpy_or_python_type)r{rM is_batch_hooks r. _process_logsCallbackList._process_logs#s; <I  ! !K T>>K44T::r0c:URRU5 grc)r*r#)r{callbacks r.r#CallbackList.append-s h'r0cXXlURHnURU5 M grc)r~r*r8)r{r~rs r.r8CallbackList.set_params0s# H    ''r0cXlUR(aURUlURHnUR U5 M grc)r(rr!r*r&)r{r(rs r.r&CallbackList.set_model5s5 == MMEMH   u %'r0cUR(dgUS:XaURXU5 gUS:XaURXU5 g[SUS35e)z4Helper function for all batch_{begin | end} methods.NbeginendzUnrecognized hook: z&. Expected values are ["begin", "end"])r*_call_batch_begin_hook_call_batch_end_hook ValueError)r{rhookbatchrMs r._call_batch_hookCallbackList._call_batch_hook<sX~~  7?  ' 'T : U]  % %d4 8%dV,77 r0cSUS3nURXBU5 UR(a[R"5Ulgg)z/Helper function for `on_*_batch_begin` methods.on_ _batch_beginN)_call_batch_hook_helperrvtimery)r{rrrM hook_names r.r#CallbackList._call_batch_begin_hookKs<$|,  $$Yt<   %)YY[D " r0c>SUS3nUR(aCUS:a=[R"5UR- nURR U5 UR XBU5 [ UR5UR:Ga UnSUS3n[UR5[ UR5- n[URU5[ URU5- n [URU5[ URU5- n SU-n Sn X:a%[R"U RUUU S95 X:a%[R"U RUUU S95 SUlS Ul/Ul0Ul g g ) z-Helper function for `on_*_batch_end` methods.r _batch_endrr?zCallback method `{hook}` is slow compared to the batch time (batch time: {batch_time:.4f}s vs `{hook}` time: {hook_time:.4f}s). Check your callbacks.)r batch_time hook_timeFN) rvrryrzr#rlenrwsumrxloggingwarningformat) r{rrrMrr end_hook_namebegin_hook_nameavg_batch_timeavg_end_hook_timeavg_begin_hook_timethreshold_time warning_msgs r.r!CallbackList._call_batch_end_hookSs$z*   %1*t'='==J    $ $Z 0 $$Yt< t  !T%G%G G%M #D66O !2!23c$:K:K6LLN #D$4$4]$C Ds  /H! #&d&6&6&G"H3  1L# !>1NJ  #3&&,#1"5'!1&&*#1"3'"'D %)D " "D !D I Hr0cUR(a[R"5nURUSS9nURHn[ XQ5nU"X#5 M UR(aSXR ;a/UR U'UR UR [R"5W- 5 gg)z+Helper function for `on_*_batch_*` methods.T)rN)rvrrr*rXrxr#)r{rrrM start_timerrs r.r$CallbackList._call_batch_hook_helpers   J!!$d!;H8/D  '    0 00.0  +   Y ' . .tyy{Z/G H r0cU[R:XaUR5 gU[R:XaUR 5 gUR 5 g)z:Helper function for on_{train|test|predict}_begin methods.N)rron_train_beginrK on_test_beginon_predict_beginr{rs r._call_begin_hookCallbackList._call_begin_hooks> 8>> !    ! X]] "     ! ! #r0cU[R:XaUR5 gU[R:XaUR 5 gUR 5 g)z8Helper function for on_{train|test|predict}_end methods.N)rr on_train_endrK on_test_endon_predict_endrs r._call_end_hookCallbackList._call_end_hooks> 8>> !     X]] "        !r0cfUR(a UR[RSXS9 gg)NrrMrrrrrr{rrMs r.on_batch_beginCallbackList.on_batch_begins)  . .  ! !(..'5 ! L /r0cfUR(a UR[RSXS9 gg)Nrrrrs r. on_batch_endCallbackList.on_batch_ends)  . .  ! !(..% ! J /r0cnURU5nURHnURX5 M g)aCalls the `on_epoch_begin` methods of its callbacks. This function should only be called during TRAIN mode. Args: epoch: Integer, index of epoch. logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. N)rr*on_epoch_beginr{epochrMrs r.rCallbackList.on_epoch_begins0!!$'H  # #E 0'r0cnURU5nURHnURX5 M g)aDCalls the `on_epoch_end` methods of its callbacks. This function should only be called during TRAIN mode. Args: epoch: Integer, index of epoch. logs: Dict, metric results for this training epoch, and for the validation epoch if validation is performed. Validation result keys are prefixed with `val_`. N)rr* on_epoch_endrs r.rCallbackList.on_epoch_ends0!!$'H  ! !% .'r0cfUR(a UR[RSXS9 gg)a4Calls the `on_train_batch_begin` methods of its callbacks. Args: batch: Integer, index of batch within the current epoch. logs: Dict, contains the return value of `model.train_step`. Typically, the values of the `Model`'s metrics are returned. Example: `{'loss': 0.2, 'accuracy': 0.7}`. rrNrrs r.on_train_batch_begin!CallbackList.on_train_batch_begins+  . .  ! !(..'5 ! L /r0cfUR(a UR[RSXS9 gg)zCalls the `on_train_batch_end` methods of its callbacks. Args: batch: Integer, index of batch within the current epoch. logs: Dict. Aggregated metric results up until this batch. rrNrrs r.on_train_batch_endCallbackList.on_train_batch_ends+  . .  ! !(..% ! J /r0cfUR(a UR[RSXS9 gg)a2Calls the `on_test_batch_begin` methods of its callbacks. Args: batch: Integer, index of batch within the current epoch. logs: Dict, contains the return value of `model.test_step`. Typically, the values of the `Model`'s metrics are returned. Example: `{'loss': 0.2, 'accuracy': 0.7}`. rrNrsrrrKrs r.on_test_batch_begin CallbackList.on_test_batch_begins+  - -  ! !(--% ! K .r0cfUR(a UR[RSXS9 gg)zCalls the `on_test_batch_end` methods of its callbacks. Args: batch: Integer, index of batch within the current epoch. logs: Dict. Aggregated metric results up until this batch. rrNrrs r.on_test_batch_endCallbackList.on_test_batch_ends+  - -  ! !(-- ! I .r0cfUR(a UR[RSXS9 gg)a!Calls the `on_predict_batch_begin` methods of its callbacks. Args: batch: Integer, index of batch within the current epoch. logs: Dict, contains the return value of `model.predict_step`, it typically returns a dict with a key 'outputs' containing the model's outputs. rrNrtrrr6rs r.on_predict_batch_begin#CallbackList.on_predict_batch_begins-  0 0  ! !("2"2GU ! N 1r0cfUR(a UR[RSXS9 gg)zCalls the `on_predict_batch_end` methods of its callbacks. Args: batch: Integer, index of batch within the current epoch. logs: Dict. Aggregated metric results up until this batch. rrNrrs r.on_predict_batch_end!CallbackList.on_predict_batch_ends-  0 0  ! !("2"2E5 ! L 1r0cnURU5nURHnURU5 M g)zCalls the `on_train_begin` methods of its callbacks. Args: logs: Dict. Currently, no data is passed via this argument for this method, but that may change in the future. N)rr*rr{rMrs r.rCallbackList.on_train_begin 0!!$'H  # #D )'r0cnURU5nURHnURU5 M g)zCalls the `on_train_end` methods of its callbacks. Args: logs: Dict. Currently, no data is passed via this argument for this method, but that may change in the future. N)rr*rrs r.rCallbackList.on_train_ends0!!$'H  ! !$ ''r0cnURU5nURHnURU5 M g)zCalls the `on_test_begin` methods of its callbacks. Args: logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. N)rr*rrs r.rCallbackList.on_test_begin!s0!!$'H  " "4 ('r0cnURU5nURHnURU5 M g)zCalls the `on_test_end` methods of its callbacks. Args: logs: Dict. Currently, no data is passed via this argument for this method, but that may change in the future. N)rr*rrs r.rCallbackList.on_test_end,s0!!$'H   &'r0cnURU5nURHnURU5 M g)zCalls the 'on_predict_begin` methods of its callbacks. Args: logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. N)rr*rrs r.rCallbackList.on_predict_begin7s0!!$'H  % %d +'r0cnURU5nURHnURU5 M g)zCalls the `on_predict_end` methods of its callbacks. Args: logs: Dict. Currently, no data is passed via this argument for this method, but that may change in the future. N)rr*rrs r.rCallbackList.on_predict_endBrr0c,[UR5$rc)iterr*r{s r.__iter__CallbackList.__iter__MsDNN##r0c[RR5nUR(a/nURHin[ USS5(aMUR 5(d,UR5(dUR5(dMXURU5 Mk U(a[SU35egg)z>Error out if batch-level callbacks are passed with PSStrategy.rWFzgBatch-level `Callback`s are not supported with `ParameterServerStrategy`. Found unsupported callbacks: N) rB distribute get_strategy_should_use_with_coordinatorr*rXr_r`rar#r)r{strategyunsupported_callbacksr[s r.ru1CallbackList._disallow_batch_hooks_in_ps_strategyPs==--/  0 0$& !nn22E::4466668899;;)004%% ""7!8:% 1r0c>UR(dU$[XX4US9$)rI)rN)r*rQ)r{r(rMrJrrNs r.rQCallbackList.make_logsgs~~KgFCCr0)rpryrzrvrrxrwrrtrsrrrWr*r(r~)NFFN)Frc)%ri __module__ __qualname____firstlineno____doc__rrnrr#r8r&rrrrrrrrrrrrrrrrrrrrrrrrurQ__static_attributes__r0r.rrs4 BH1&;(( & 1."` I$"MK 1 / MK LJ OM * ( ) ' , *$.Dr0rzkeras.callbacks.Callbackc\rSrSrSrSrSrSr\R\ RSSj55r \R\ RSSj55r \RSS j5r\RSS j5r\R\ RSS j55r\R\ RSS j55r\R\ RSS j55r\R\ RSSj55r\R\ RSSj55r\R\ RSSj55r\RSSj5r\RSSj5r\RSSj5r\RSSj5r\RSSj5r\RSSj5rSrSrSrSrg)CallbackioaAbstract base class used to build new callbacks. Callbacks can be passed to keras methods such as `fit`, `evaluate`, and `predict` in order to hook into the various stages of the model training and inference lifecycle. To create a custom callback, subclass `keras.callbacks.Callback` and override the method associated with the stage of interest. See https://www.tensorflow.org/guide/tf_keras/custom_callback for more information. Example: >>> training_finished = False >>> class MyCallback(tf.keras.callbacks.Callback): ... def on_train_end(self, logs=None): ... global training_finished ... training_finished = True >>> model = tf.keras.Sequential([ ... tf.keras.layers.Dense(1, input_shape=(1,))]) >>> model.compile(loss='mean_squared_error') >>> model.fit(tf.constant([[1.0]]), tf.constant([[1.0]]), ... callbacks=[MyCallback()]) >>> assert training_finished == True If you want to use `Callback` objects in a custom training loop: 1. You should pack all your callbacks into a single `callbacks.CallbackList` so they can all be called together. 2. You will need to manually call all the `on_*` methods at the appropriate locations in your loop. Like this: Example: ```python callbacks = tf.keras.callbacks.CallbackList([...]) callbacks.append(...) callbacks.on_train_begin(...) for epoch in range(EPOCHS): callbacks.on_epoch_begin(epoch) for i, data in dataset.enumerate(): callbacks.on_train_batch_begin(i) batch_logs = model.train_step(data) callbacks.on_train_batch_end(i, batch_logs) epoch_logs = ... callbacks.on_epoch_end(epoch, epoch_logs) final_logs=... callbacks.on_train_end(final_logs) ``` Attributes: params: Dict. Training parameters (eg. verbosity, batch size, number of epochs...). model: Instance of `keras.models.Model`. Reference of the model being trained. The `logs` dictionary that callback methods take as argument will contain keys for quantities relevant to the current batch or epoch (see method-specific docstrings). c<SUlSUlSUlSUlg)NF)validation_datar(_chief_worker_onlyrWrs r.rCallback.__init__s## #'!&r0cXlgrc)r~r{r~s r.r8Callback.set_paramss r0cXlgrc)r(r{r(s r.r&Callback.set_models r0Ncg)z;A backwards compatibility alias for `on_train_batch_begin`.Nr rs r.rCallback.on_batch_beginr0cg)z9A backwards compatibility alias for `on_train_batch_end`.Nr rs r.rCallback.on_batch_endrr0cg)a-Called at the start of an epoch. Subclasses should override for any actions to run. This function should only be called during TRAIN mode. Args: epoch: Integer, index of epoch. logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. Nr r{rrMs r.rCallback.on_epoch_beginrr0cg)aCalled at the end of an epoch. Subclasses should override for any actions to run. This function should only be called during TRAIN mode. Args: epoch: Integer, index of epoch. logs: Dict, metric results for this training epoch, and for the validation epoch if validation is performed. Validation result keys are prefixed with `val_`. For training epoch, the values of the `Model`'s metrics are returned. Example: `{'loss': 0.2, 'accuracy': 0.7}`. Nr rs r.rCallback.on_epoch_endrr0c"URXS9 g)aCalled at the beginning of a training batch in `fit` methods. Subclasses should override for any actions to run. Note that if the `steps_per_execution` argument to `compile` in `tf.keras.Model` is set to `N`, this method will only be called every `N` batches. Args: batch: Integer, index of batch within the current epoch. logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. rN)rrs r.rCallback.on_train_batch_begins" E-r0c"URXS9 g)aCalled at the end of a training batch in `fit` methods. Subclasses should override for any actions to run. Note that if the `steps_per_execution` argument to `compile` in `tf.keras.Model` is set to `N`, this method will only be called every `N` batches. Args: batch: Integer, index of batch within the current epoch. logs: Dict. Aggregated metric results up until this batch. rN)rrs r.rCallback.on_train_batch_ends %+r0cg)a&Called at the beginning of a batch in `evaluate` methods. Also called at the beginning of a validation batch in the `fit` methods, if validation data is provided. Subclasses should override for any actions to run. Note that if the `steps_per_execution` argument to `compile` in `tf.keras.Model` is set to `N`, this method will only be called every `N` batches. Args: batch: Integer, index of batch within the current epoch. logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. Nr rs r.rCallback.on_test_batch_beginrr0cg)aCalled at the end of a batch in `evaluate` methods. Also called at the end of a validation batch in the `fit` methods, if validation data is provided. Subclasses should override for any actions to run. Note that if the `steps_per_execution` argument to `compile` in `tf.keras.Model` is set to `N`, this method will only be called every `N` batches. Args: batch: Integer, index of batch within the current epoch. logs: Dict. Aggregated metric results up until this batch. Nr rs r.rCallback.on_test_batch_endrr0cg)aCalled at the beginning of a batch in `predict` methods. Subclasses should override for any actions to run. Note that if the `steps_per_execution` argument to `compile` in `tf.keras.Model` is set to `N`, this method will only be called every `N` batches. Args: batch: Integer, index of batch within the current epoch. logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. Nr rs r.rCallback.on_predict_batch_begin/rr0cg)a~Called at the end of a batch in `predict` methods. Subclasses should override for any actions to run. Note that if the `steps_per_execution` argument to `compile` in `tf.keras.Model` is set to `N`, this method will only be called every `N` batches. Args: batch: Integer, index of batch within the current epoch. logs: Dict. Aggregated metric results up until this batch. Nr rs r.rCallback.on_predict_batch_end@rr0cg)zCalled at the beginning of training. Subclasses should override for any actions to run. Args: logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. Nr r{rMs r.rCallback.on_train_beginPrr0cg)zCalled at the end of training. Subclasses should override for any actions to run. Args: logs: Dict. Currently the output of the last call to `on_epoch_end()` is passed to this argument for this method but that may change in the future. Nr r0s r.rCallback.on_train_end[rr0cg)zCalled at the beginning of evaluation or validation. Subclasses should override for any actions to run. Args: logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. Nr r0s r.rCallback.on_test_begingrr0cg)aCalled at the end of evaluation or validation. Subclasses should override for any actions to run. Args: logs: Dict. Currently the output of the last call to `on_test_batch_end()` is passed to this argument for this method but that may change in the future. Nr r0s r.rCallback.on_test_endrrr0cg)zCalled at the beginning of prediction. Subclasses should override for any actions to run. Args: logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. Nr r0s r.rCallback.on_predict_begin~rr0cg)zCalled at the end of prediction. Subclasses should override for any actions to run. Args: logs: Dict. Currently no data is passed to this argument for this method but that may change in the future. Nr r0s r.rCallback.on_predict_endrr0cT[R"UR5(+=(d} [R"UR5(+=(dQ [R"UR5(+=(d% [R"UR 5(+$)zBDetermines if this Callback should be called for each train batch.)r is_defaultrrrrrs r.r_&Callback._implements_train_batch_hookssy(()<)<= = E ++D,=,=>> E ++D,E,EFF E!++D,C,CDD  r0c[R"UR5(+=(d% [R"UR5(+$)zADetermines if this Callback should be called for each test batch.)rr=rrrs r.r`%Callback._implements_test_batch_hookssA ++  $ $  B))$*@*@A A Br0c[R"UR5(+=(d% [R"UR5(+$)zDDetermines if this Callback should be called for each predict batch.)rr=rrrs r.ra(Callback._implements_predict_batch_hookssC!++  ' '  E))$*C*CD D Er0)rrWr(r~rrc) rirrr r rr8r&rfor_subclass_implementersrdefaultrrrrrrrrrrrrrrrrr_r`rar r r0r.rros<:x'++J,J++H,H++  ,  ++  ,  ++.,."++,,, ++ , $++ , "++  ,  ++  ,  ++ , ++  ,  ++ , ++  ,  ++ , ++ ,  B Er0rzkeras.callbacks.BaseLoggercN^\rSrSrSrSU4SjjrSSjrSSjrSSjrSr U=r $) r"iahCallback that accumulates epoch averages of metrics. This callback is automatically applied to every TF-Keras model. Args: stateful_metrics: Iterable of string names of metrics that should *not* be averaged over an epoch. Metrics in this list will be logged as-is in `on_epoch_end`. All others will be averaged in `on_epoch_end`. cT>[TU]5 [U=(d /5Ulgrc)superrsetr5)r{r5rhs r.rBaseLogger.__init__s!  #$4$: ;r0c SUl0UlgNr)seentotalsrs r.rBaseLogger.on_epoch_begins  r0cvU=(d 0nURSS5nURSS5nU=RX4-- slUR5H_upVXPR;aX`RU'M$XPR;aURU==Xc-- ss'MNXc-URU'Ma g)Nsizer num_stepsr)getrLitemsr5rM)r{rrMrrQkvs r.rBaseLogger.on_batch_endszrXXfa( HH[!,  Z++ JJLDA)))!" A #KKNan4N%&^DKKN!r0cUbhURSHTnX0R;dMX0R;aURUX#'M6URUUR- X#'MV gg)Nr3)r~rMr5rL)r{rrMrTs r.rBaseLogger.on_epoch_ends]  [[+ #111"&++a."&++a.499"< , r0)rLr5rMrc) rirrr r rrrrr  __classcell__rhs@r.r"r"s! <4$==r0r"zkeras.callbacks.TerminateOnNaNc6^\rSrSrSrU4SjrSSjrSrU=r$)TerminateOnNaNizACallback that terminates training when a NaN loss is encountered.c0>[TU]5 SUlgNT)rGrrWr{rhs r.rTerminateOnNaN.__init__s !%r0c4U=(d 0nURS5nUby[R"U5n[R"U5(d[R "U5(a,[ R"SUS35 SURl ggg)NlosszBatch z$: Invalid loss, terminating trainingT) rRr rnpisnanisinfr print_msgr(r))r{rrMrbs r.rTerminateOnNaN.on_batch_ends{zrxx  88>Dxx~~$""UG#GH,0 ( "0 r0)rWrc) rirrr r rrr rYrZs@r.r\r\sK& 0 0r0r\zkeras.callbacks.ProgbarLoggerc^\rSrSrSrSS\4U4SjjjrSrSSjrSSjr SSjr SS jr SS jr SS jr SS jrSS jrSSjrSSjrSrSrSrSrSrSSjrSrSrU=r$)r$iaCallback that prints metrics to stdout. Args: count_mode: One of `"steps"` or `"samples"`. Whether the progress bar should count samples seen or steps (batches) seen. stateful_metrics: Iterable of string names of metrics that should *not* be averaged over an epoch. Metrics in this list will be logged as-is. All others will be averaged over time (e.g. loss, etc). If not provided, defaults to the `Model`'s metrics. Raises: ValueError: In case of invalid `count_mode`. r+cT>[TU]5 SUlUS:XaSUlOUS:XaSUlO[ SUS35eU(a [ U5O [ 5UlSUlSUlSUl SUl SUl S uUl Ul UlSUlSUlg) NTrFrzUnknown `count_mode`: z*. Expected values are ["samples", "steps"]rr)NNN)rGrrW use_stepsrrHr5rLprogbartargetrr _train_step _test_step _predict_step_call_batch_hooks_called_in_fit)r{r+r5rhs r.rProgbarLogger.__init__s !%  ""DN 7 "!DN( 5;;  &6C !35      @P=$/4+=!%#r0cUSUlUSUlUR(aSU;a USUlO)UR(dSU;a USUlOSUlURS:HUlURcSUR R UlUR RUl UR RUl gg![a SUlgf=f)NrrrrrT) rrrjrlrpr(_train_counterrm _test_counterrn_predict_counterroAttributeErrorrs r.r8ProgbarLogger.set_paramssi( X& >>g/ /DKI$7 +DK K"&!2 ;;  .#'::#<#< "&**":":%)ZZ%@%@"  " .)-& .sACC)(C)cSUlgr^)rqr0s r.rProgbarLogger.on_train_begin4s "r0chUR(d!UR5 UR5 ggrc)rq_reset_progbar_maybe_init_progbarr0s r.rProgbarLogger.on_test_begin8s(""    !  $ $ &#r0cDUR5 UR5 grc)r|r}r0s r.rProgbarLogger.on_predict_begin=s    "r0cUR5 UR5 UR(a;URS:a*[R "SUS-SUR35 ggg)NrEpoch /)r|r}rrr rfrs r.rProgbarLogger.on_epoch_beginAsU    " <.ms7$6qFF$6sNstepsample)rlrr5 unit_name) rHr5r(unionr3rkr rlrrj_update_stateful_metricsrs r.r}!ProgbarLogger._maybe_init_progbar`s !$D$9$9 : ::%)$9$9$?$?7DJJ$6$677%D ! << "{{ !%!6!6$(NN& DL --d.C.CDr0cUR$rcrprs r.r_+ProgbarLogger._implements_train_batch_hooksz%%%r0cUR$rcrrs r.r`*ProgbarLogger._implements_test_batch_hooks}rr0cUR$rcrrs r.ra-ProgbarLogger._implements_predict_batch_hooksrr0cU=(d 0nUR5 UR(a US-UlOe[R"U5nUR SS5nUR SS5nUR SS5 XC-nU=RU- slUR S:XaS[ R"U5nURRUR[UR55SS9 gg) zUpdates the progbar.rrPrrQrNFfinalize) r}rjrLr7poprr rrkupdatelistrS)r{rrMrrQadd_seens r.r#ProgbarLogger._batch_update_progbarszr   " >> DI99T?D&!,Ja0I HHWd # -H II !I <<1 88>D LL   4 +=  N r0c[R"U=(d 05nURcmUb5UR5nUR(dX!R SS5-nU=(d UR UlURURlURRUR[UR55SS9 g)NrPrTr) r rrlnumpyrjrRrLrkrrrS)r{rMcounters r.rProgbarLogger._finalize_progbars44TZR@ ;; "!--/~~xx22G!.TYYDK"&++DLL  DKKdjjl);dKr0) rprqrorWrnrmrrkrLr5rlrjr)rNrc)rirrr r strrr8rrrrrrrrrrr|r}r_r`rarrr rYrZs@r.r$r$s} $3$$8.*#' #C 0407:9E4&&&O( L Lr0r$zkeras.callbacks.Historyc@^\rSrSrSrU4SjrSSjrSSjrSrU=r $)r iaTCallback that records events into a `History` object. This callback is automatically applied to every TF-Keras model. The `History` object gets returned by the `fit` method of models. Example: >>> model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)]) >>> model.compile(tf.keras.optimizers.SGD(), loss='mse') >>> history = model.fit(np.arange(100).reshape(5, 20), np.zeros(5), ... epochs=10, verbose=1) >>> print(history.params) {'verbose': 1, 'epochs': 10, 'steps': 1} >>> # check the keys of history object >>> print(history.history.keys()) dict_keys(['loss']) c0>[TU]5 0Ulgrc)rGrr!r_s r.rHistory.__init__s  r0c/Ulgrcrr0s r.rHistory.on_train_begins  r0cU=(d 0nURRU5 UR5H0up4URR U/5RU5 M2 XR lgrc)rr#rSr! setdefaultr()r{rrMrTrUs r.rHistory.on_epoch_endsZzr % JJLDA LL # #Ar * 1 1! 4! " r0)rr!rc) rirrr r rrrr rYrZs@r.r r s(""r0r zkeras.callbacks.ModelCheckpointc ^\rSrSrSrSS\S\S\S\S\4 U4SjjjrSS jr S r SS jr SS jr SS jr SrSrSrSrSrSrSrSrU=r$)ModelCheckpointia#Callback to save the TF-Keras model or model weights at some frequency. `ModelCheckpoint` callback is used in conjunction with training using `model.fit()` to save a model or weights (in a checkpoint file) at some interval, so the model or weights can be loaded later to continue the training from the state saved. A few options this callback provides include: - Whether to only keep the model that has achieved the "best performance" so far, or whether to save the model at the end of every epoch regardless of performance. - Definition of 'best'; which quantity to monitor and whether it should be maximized or minimized. - The frequency it should save at. Currently, the callback supports saving at the end of every epoch, or after a fixed number of training batches. - Whether only weights are saved, or the whole model is saved. Note: If you get `WARNING:tensorflow:Can save best model only with available, skipping` see the description of the `monitor` argument for details on how to get this right. Example: ```python model.compile(loss=..., optimizer=..., metrics=['accuracy']) EPOCHS = 10 checkpoint_filepath = '/tmp/checkpoint' model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint( filepath=checkpoint_filepath, save_weights_only=True, monitor='val_accuracy', mode='max', save_best_only=True) # Model weights are saved at the end of every epoch, if it's the best seen # so far. model.fit(epochs=EPOCHS, callbacks=[model_checkpoint_callback]) # The model weights (that are considered the best) are loaded into the # model. model.load_weights(checkpoint_filepath) ``` Args: filepath: string or `PathLike`, path to save the model file. e.g. filepath = os.path.join(working_dir, 'ckpt', file_name). `filepath` can contain named formatting options, which will be filled the value of `epoch` and keys in `logs` (passed in `on_epoch_end`). For example: if `filepath` is `weights.{epoch:02d}-{val_loss:.2f}.hdf5`, then the model checkpoints will be saved with the epoch number and the validation loss in the filename. The directory of the filepath should not be reused by any other callbacks to avoid conflicts. monitor: The metric name to monitor. Typically the metrics are set by the `Model.compile` method. Note: * Prefix the name with `"val_`" to monitor validation metrics. * Use `"loss"` or "`val_loss`" to monitor the model's total loss. * If you specify metrics as strings, like `"accuracy"`, pass the same string (with or without the `"val_"` prefix). * If you pass `metrics.Metric` objects, `monitor` should be set to `metric.name` * If you're not sure about the metric names you can check the contents of the `history.history` dictionary returned by `history = model.fit()` * Multi-output models set additional prefixes on the metric names. verbose: Verbosity mode, 0 or 1. Mode 0 is silent, and mode 1 displays messages when the callback takes an action. save_best_only: if `save_best_only=True`, it only saves when the model is considered the "best" and the latest best model according to the quantity monitored will not be overwritten. If `filepath` doesn't contain formatting options like `{epoch}` then `filepath` will be overwritten by each new better model. mode: one of {'auto', 'min', 'max'}. If `save_best_only=True`, the decision to overwrite the current save file is made based on either the maximization or the minimization of the monitored quantity. For `val_acc`, this should be `max`, for `val_loss` this should be `min`, etc. In `auto` mode, the mode is set to `max` if the quantities monitored are 'acc' or start with 'fmeasure' and are set to `min` for the rest of the quantities. save_weights_only: if True, then only the model's weights will be saved (`model.save_weights(filepath)`), else the full model is saved (`model.save(filepath)`). save_freq: `'epoch'` or integer. When using `'epoch'`, the callback saves the model after each epoch. When using integer, the callback saves the model at end of this many batches. If the `Model` is compiled with `steps_per_execution=N`, then the saving criteria will be checked every Nth batch. Note that if the saving isn't aligned to epochs, the monitored metric may potentially be less reliable (it could reflect as little as 1 batch, since the metrics get reset every epoch). Defaults to `'epoch'`. options: Optional `tf.train.CheckpointOptions` object if `save_weights_only` is true or optional `tf.saved_model.SaveOptions` object if `save_weights_only` is false. initial_value_threshold: Floating point initial "best" value of the metric to be monitored. Only applies if `save_best_value=True`. Only overwrites the model weights already saved if the performance of current model is better than this value. **kwargs: Additional arguments for backwards compatibility. Possible key is `period`. monitorrsave_best_onlysave_weights_onlyrc  >[T U]5 SUlX lX0l[ R "U5UlX@lXPl Xpl SUl SUl SUl XlU(ahUb)[U[ R"R$5(a-U=(d [ R"R%5UlO[)SUS35eU(a$UR+S5(aUb [-S5eUb)[U[ R.R05(a-U=(d [ R.R15UlO[)SUS35eS U ;a!U S Ul[4R6"S 5 OS UlS U ;a!U S Ul[4R6"S 5 OSUlUS;a[4R6"SU5 SnUS:Xa8[:R<UlURc[:R@UlOUS:Xa9[:RBUlURc[:R@*UlOSUR;d URRES5(a9[:RBUlURc[:R@*UlO7[:R<UlURc[:R@UlURS:wa8[UR[F5(d[-SURS35eS Ul$g)NTrzfIf save_weights_only is True, then `options` must be either None or a tf.train.CheckpointOptions. Got ..keraszThe native TF-Keras format does not support the `options` argument. Please remove the `options` argument, or use the SavedModel format by removing the `.keras` extension from the model filepath.zgIf save_weights_only is False, then `options` must be either None or a tf.saved_model.SaveOptions. Got load_weights_on_restartz`load_weights_on_restart` argument is deprecated. Please use `model.load_weights()` for loading weights before the start of `model.fit()`.Fperiodzk`period` argument is deprecated. Please use `save_freq` to specify the frequency in number of batches seen.rautominmaxz:ModelCheckpoint mode %s is unknown, fallback to auto mode.rrraccfmeasurerzUnrecognized save_freq: z+. Expected save_freq are "epoch" or integer)%rGrrWrrr path_to_stringfilepathrr save_freqepochs_since_last_save_batches_seen_since_last_saving_last_batch_seenbestrrBtrainCheckpointOptions_options TypeErrorendswithr saved_model SaveOptionsrrrrrcless monitor_opInfgreater startswithintr) r{rrrrrrroptionsinitial_value_thresholdkwargsrhs r.rModelCheckpoint.__init__6s !%   //9 ,!2"&'#/0, "+ *33##!( G288+E+E+G ")1& H--h77G>+E+E+G ")1& % .+12K+LD ( OO5  ,1D ( v  *DK OOF  DK - - OOL D 5= ggDOyy FF U] jjDOyy VVG  $ (?(? (K(K"$**99$!#DI"$''99$ "DI >>W $Z-L-L*4>>*:;<< #(r0cUR(aSURUR5nUb4URU5(aURR U5 gggg![ [4an[SUSU35eSnAff=f)NzError loading file from z . Reason: )r1_get_most_recently_modified_file_matching_patternr_checkpoint_existsr( load_weightsIOErrorr)r{rMfilepath_to_loades r.rModelCheckpoint.on_train_begins  ' 'FFMM   +0G0G 11 JJ++,<=1+ ( ,$23C2DE##$#'sA&&B 6BB c URS:g$Nrrrs r.r_-ModelCheckpoint._implements_train_batch_hookss~~((r0cfURU5(aURURXS9 gg)NrrrM)_should_save_on_batch _save_model_current_epochrs r.r"ModelCheckpoint.on_train_batch_ends1  % %e , ,   4#6#6e  O -r0cXlgrc)rrs r.rModelCheckpoint.on_epoch_begins#r0crU=RS- slURS:XaURUSUS9 gg)Nrrr)rrrrs r.rModelCheckpoint.on_epoch_ends9 ##q(# >>W $   54  @ %r0cURS:XagXR::aUS-nOXR- nU=RU- slXlURUR:aSUlgg)z?Handles batch-level saving logic, supports steps_per_execution.rFrrT)rrr)r{r add_batchess r.r%ModelCheckpoint._should_save_on_batchsk >>W $ )) )!)K"7"77K ,, ;, %  / /4>> A34D 0r0c U=(d 0n[UR[5(dURUR:Ga5[ R "U5nSUlURXU5n[RRU5nU(amURS5(dW[RRRU5(d)[RRR!U5 UR"(GaUR%UR&5nUc#[(R*"SUR&5 GOUR-X`R.5(afUR0S:a>[2R4"SUS-SUR&SUR.S S US S U3 5 X`lUR7U5 OUR0S:a7[2R4"SUS-SUR&S UR.S 35 O@UR0S:a[2R4"SUS-S U35 UR7U5 UR95 gg![:a [=SU35e[<a?nS[?UR@S5RC5;a[=SU35eUeSnAff=f)zSaves the model. Args: epoch: the epoch this iteration is in. batch: the batch this iteration is in. `None` if the `save_freq` is set to `epoch`. logs: the `logs` dict passed in to `on_batch_end` or `on_epoch_end`. rzgs://Nz5Can save best model only with %s available, skipping. Epoch rz: z improved from z.5fz to z, saving model to z did not improve from z: saving model to zePlease specify a non-directory filepath for ModelCheckpoint. Filepath used is an existing directory: zis a directoryzfPlease specify a non-directory filepath for ModelCheckpoint. Filepath used is an existing directory: f)"rrrrrr r_get_file_pathospathdirnamerrBiogfileexistsmakedirsrrRrrrrrrr rf _save_handler_maybe_remove_fileIsADirectoryErrorrrargslower)r{rrrMrrcurrentrs r.rModelCheckpoint._save_modelszr t~~s + +**dkk988>D*+D '**5>Hggooh/G**733 **733 $$W-7 &&&"hht||4G( LL  ??7II>>#||a/ ( 2 2&.uqykDLL>J,,0IIc?$wsmL77?j%B!" )0I!..x8#||a/ ( 2 2&.uqyk'+||n5,,0IIc?%<!" ||a' **&uqyk1CH:N &&x0'')k:l% ""*-  $s166!9~';';'==!''/j2  s E1I<,> x - )%I(IIr0c*[RRU5n[RRU5nS[R "SSU5-S-n[ RRU5nUb;[R"U[RRU55(aU$SnSnSnSn [ RRRU5(a[R"U5Hn [R"XJ5(dM [RRX*5n [RRU 5n U bX:aU n X:aU nU nSnMuX:XdM|US- nM US:XaU$U $)aReturns the most recently modified filepath matching pattern. Pattern may contain python formatting placeholder. If `tf.train.latest_checkpoint()` does not return None, use that; otherwise, check for most recently modified one that matches the pattern. In the rare case where there are more than one pattern-matching file having the same modified time that is most recent among all, return the filepath that is largest (by `>` operator, lexicographically using the numeric equivalents). This provides a tie-breaker when multiple files are most recent. Note that a larger `filepath` can sometimes indicate a later time of modification (for instance, when epoch/batch is used as formatting option), but not necessarily (when accuracy or loss is used). The tie-breaker is put in the logic as best effort to return the most recent, and to avoid undeterministic result. Modified time of a file is obtained with `os.path.getmtime()`. This utility function is best demonstrated via an example: ```python file_pattern = 'f.batch{batch:02d}epoch{epoch:02d}.h5' test_dir = self.get_temp_dir() path_pattern = os.path.join(test_dir, file_pattern) file_paths = [ os.path.join(test_dir, file_name) for file_name in ['f.batch03epoch02.h5', 'f.batch02epoch02.h5', 'f.batch01epoch01.h5'] ] for file_path in file_paths: # Write something to each of the files self.assertEqual( _get_most_recently_modified_file_matching_pattern(path_pattern), file_paths[-1]) ``` Args: pattern: The file pattern that may optionally contain python placeholder such as `{epoch:02d}`. Returns: The most recently modified file's full filepath matching `pattern`. If `pattern` does not contain any placeholder, this returns the filepath that exactly matches `pattern`. Returns `None` if no match is found. ^z{.*}z.*$Nrr)rrrbasenameresubrBrlatest_checkpointmatchrrr listdirjoingetmtime) r{patterndir_name base_namebase_name_regexlatest_tf_checkpointlatest_mod_timefile_path_with_latest_mod_timen_file_with_latest_mod_time file_path_with_largest_file_name file_namermod_times r.rAModelCheckpoint._get_most_recently_modified_file_matching_patternws_`77??7+GG$$W- wy AACG "xx99(C  + RWW--.BC1 1 ( ')-&&'#+/( 55;;  h ' 'ZZ1 88O77 " X AI!ww// :H8@$G;D81*29B6783!44q83+2. '! +1 14 3r0)rrrrrrWrrrrrrrrrrrr)val_lossrFFrrNNrc)rirrr r rrboolrrr_rrrrrr rr rrr rYrZs@r.rrsgX"$"' $r(r( r(  r(  r(r(r(h*)P$A "Sj.$0 J_4_4r0rz keras.callbacks.BackupAndRestore)rDc^\rSrSrSrS U4SjjrSSjrSSjrSSjrSr SSjr SS jr SS jr SS jr S rU=r$)BackupAndRestoreiaCallback to back up and restore the training state. `BackupAndRestore` callback is intended to recover training from an interruption that has happened in the middle of a `Model.fit` execution, by backing up the training states in a temporary checkpoint file (with the help of a `tf.train.CheckpointManager`), at the end of each epoch. Each backup overwrites the previously written checkpoint file, so at any given time there is at most one such checkpoint file for backup/restoring purpose. If training restarts before completion, the training state (which includes the `Model` weights and epoch number) is restored to the most recently saved state at the beginning of a new `Model.fit` run. At the completion of a `Model.fit` run, the temporary checkpoint file is deleted. Note that the user is responsible to bring jobs back after the interruption. This callback is important for the backup and restore mechanism for fault tolerance purpose, and the model to be restored from a previous checkpoint is expected to be the same as the one used to back up. If user changes arguments passed to compile or fit, the checkpoint saved for fault tolerance can become invalid. Note: 1. This callback is not compatible with eager execution disabled. 2. A checkpoint is saved at the end of each epoch. After restoring, `Model.fit` redoes any partial work during the unfinished epoch in which the training got restarted (so the work done before the interruption doesn't affect the final model state). 3. This works for both single worker and multi-worker modes. When `Model.fit` is used with `tf.distribute`, it supports `tf.distribute.MirroredStrategy`, `tf.distribute.MultiWorkerMirroredStrategy`, `tf.distribute.TPUStrategy`, and `tf.distribute.experimental.ParameterServerStrategy`. Example: >>> class InterruptingCallback(tf.keras.callbacks.Callback): ... def on_epoch_begin(self, epoch, logs=None): ... if epoch == 4: ... raise RuntimeError('Interrupting!') >>> callback = tf.keras.callbacks.BackupAndRestore(backup_dir="/tmp/backup") >>> model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)]) >>> model.compile(tf.keras.optimizers.SGD(), loss='mse') >>> try: ... model.fit(np.arange(100).reshape(5, 20), np.zeros(5), epochs=10, ... batch_size=1, callbacks=[callback, InterruptingCallback()], ... verbose=0) ... except: ... pass >>> history = model.fit(np.arange(100).reshape(5, 20), np.zeros(5), ... epochs=10, batch_size=1, callbacks=[callback], ... verbose=0) >>> # Only 6 more epochs are run, since first training got interrupted at >>> # zero-indexed epoch 4, second training will continue from 4 to 9. >>> len(history.history['loss']) 6 Besides the option to save at the end of every epoch or every N steps, if you are doing distributed training with `tf.distribute.MultiWorkerMirroredStrategy` on Google Cloud Platform or Google Borg, you can also use the `save_before_preemption` argument to enable saving a checkpoint right before a worker gets preempted by other jobs and training gets interrupted. See `tf.distribute.experimental.PreemptionCheckpointHandler` for more details. Args: backup_dir: String, path to store the checkpoint. e.g. `backup_dir = os.path.join(working_dir, 'backup')`. This is the directory in which the system stores temporary files to recover the model from jobs terminated unexpectedly. The directory cannot be reused elsewhere to store other files, e.g. by the `BackupAndRestore` callback of another training run, or by another callback (e.g. `ModelCheckpoint`) of the same training. save_freq: `'epoch'`, integer, or `False`. When set to `'epoch'` the callback saves the checkpoint at the end of each epoch. When set to an integer, the callback saves the checkpoint every `save_freq` batches. Set `save_freq` to `False` if only using preemption checkpointing (with `save_before_preemption=True`). delete_checkpoint: Boolean, default to True. This `BackupAndRestore` callback works by saving a checkpoint to back up the training state. If `delete_checkpoint=True`, the checkpoint will be deleted after training is finished. Use `False` if you'd like to keep the checkpoint for future usage. save_before_preemption: A boolean value instructing whether to turn on the automatic checkpoint saving for preemption/maintenance events. This only supports `tf.distribute.MultiWorkerMirroredStrategy` on Google Cloud Platform or Google Borg for now. c>[TU]5 XlSUl[R R [R R[R RR[R R[R RR4Ul X l X0l X@lSUlSUl[R""5(d0[R$"5(a ['S5e['S5eU(dU(d ['S5eSUlg)NTrz\This Callback's method contains Python state and should be called outside of `tf.function`s.zBackupAndRestore only supports eager mode. In graph mode, consider using ModelCheckpoint to manually save and restore weights with `model.load_weights()` and by providing `initial_epoch` in `model.fit()` for fault tolerance.z;Either `save_freq` or `save_before_preemption` must be set.F)rGr backup_dirrWrBrMirroredStrategyMultiWorkerMirroredStrategy experimental TPUStrategyParameterServerStrategy_supported_strategiesrdelete_checkpointsave_before_preemption_batches_countrexecuting_eagerlyinside_functionrr)r{rBrrIrJrhs r.rBackupAndRestore.__init__6s $!% MM * * MM 5 5 MM & & 2 2 MM % % MM & & > > & "#!2&<###%%!!## B !!$:P  #(r0cURR(aZ[URRUR5(d+[ [ URR5S35e[R"URURURUR5URl URRUl URR5 g)Nz is not supported yet. Currently BackupAndRestore callback only supports empty strategy, MirroredStrategy, MultiWorkerMirroredStrategy and TPUStrategy.)r(_distribution_strategyrrrHNotImplementedErrortyperWorkerTrainingStaterBrrJ_training_staterestorer0s r.rBackupAndRestore.on_train_beginds :: , ,Z JJ * *D,F,F6 6 & 66789QQ  &;%N%N JJ OO NN  ' ' &  " $zz99 $$&r0c[URR[RR 5(agUR RRU5 grc) rr(rrBrrGrT_ckpt_saved_batchassignrs r.r%BackupAndRestore.on_train_batch_beginzsH  JJ * * MM 1 1    ..55e>dnn7   1 $ ""dnn4&'# 4#6#6e D58>r0c URS:g$rrrs r.r_.BackupAndRestore._implements_train_batch_hookss~~((r0cvUR(aURR5 U?UR?grc)rIrT delete_backupr(r0s r.rBackupAndRestore.on_train_ends/  ! !  . . 0  JJ &r0cZURRRU5 Xlgrc)rT_ckpt_saved_epochrYrrs r.rBackupAndRestore.on_epoch_begins" ..55e<#r0cDURS:XaURUS9 gg)Nrr)rr]rs r.rBackupAndRestore.on_epoch_ends! >>W $ LLuL % %r0c6URRXS9 g)Nr)rTback_up)r{rrs r.r]BackupAndRestore._backups $$5$>r0) rKrrrHrWrTrBrIrJr)rTFrcr)rirrr r rrrrr_rrrr]r rYrZs@r.r@r@sIY|$ ,(\',= E)'$& ??r0r@z-keras.callbacks.experimental.BackupAndRestorec,^\rSrSrSrU4SjrSrU=r$)BackupAndRestoreExperimentalizDeprecated. Please use `tf.keras.callbacks.BackupAndRestore` instead. Caution: `tf.keras.callbacks.experimental.BackupAndRestore` endpoint is deprecated and will be removed in a future release. Please use `tf.keras.callbacks.BackupAndRestore`. cR>[R"S5 [TU] "U0UD6 g)Nz`tf.keras.callbacks.experimental.BackupAndRestore` endpoint is deprecated and will be removed in a future release. Please use `tf.keras.callbacks.BackupAndRestore`.)rrrGr)r{rrrhs r.r%BackupAndRestoreExperimental.__init__s( 5 $)&)r0r rirrr r rr rYrZs@r.rnrns **r0rnzkeras.callbacks.EarlyStoppingcj^\rSrSrSrS U4SjjrS SjrS SjrS SjrSr Sr S r U=r $) EarlyStoppingia Stop training when a monitored metric has stopped improving. Assuming the goal of a training is to minimize the loss. With this, the metric to be monitored would be `'loss'`, and mode would be `'min'`. A `model.fit()` training loop will check at end of every epoch whether the loss is no longer decreasing, considering the `min_delta` and `patience` if applicable. Once it's found no longer decreasing, `model.stop_training` is marked True and the training terminates. The quantity to be monitored needs to be available in `logs` dict. To make it so, pass the loss or metrics at `model.compile()`. Args: monitor: Quantity to be monitored. min_delta: Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute change of less than min_delta, will count as no improvement. patience: Number of epochs with no improvement after which training will be stopped. verbose: Verbosity mode, 0 or 1. Mode 0 is silent, and mode 1 displays messages when the callback takes an action. mode: One of `{"auto", "min", "max"}`. In `min` mode, training will stop when the quantity monitored has stopped decreasing; in `"max"` mode it will stop when the quantity monitored has stopped increasing; in `"auto"` mode, the direction is automatically inferred from the name of the monitored quantity. baseline: Baseline value for the monitored quantity. Training will stop if the model doesn't show improvement over the baseline. restore_best_weights: Whether to restore model weights from the epoch with the best value of the monitored quantity. If False, the model weights obtained at the last step of training are used. An epoch will be restored regardless of the performance relative to the `baseline`. If no epoch improves on `baseline`, training will run for `patience` epochs and restore weights from the best epoch in that set. start_from_epoch: Number of epochs to wait before starting to monitor improvement. This allows for a warm-up period in which no improvement is expected and thus training will not be stopped. Example: >>> callback = tf.keras.callbacks.EarlyStopping(monitor='loss', patience=3) >>> # This callback will stop the training when there is no improvement in >>> # the loss for three consecutive epochs. >>> model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)]) >>> model.compile(tf.keras.optimizers.SGD(), loss='mse') >>> history = model.fit(np.arange(100).reshape(5, 20), np.zeros(5), ... epochs=10, batch_size=1, callbacks=[callback], ... verbose=0) >>> len(history.history['loss']) # Only 4 epochs are run. 4 c  >[T U]5 XlX0lX@lX`l[ U5UlSUlSUl Xpl SUl Xl US;a[R"SU5 SnUS:Xa[R UlOUS:Xa[R$UlOURR'S5(d@URR'S5(d URR'S 5(a[R$UlO[R UlUR"[R$:XaU=RS -slgU=RS -slg) Nrrz8EarlyStopping mode %s is unknown, fallback to auto mode.rrrraccuracyaucrr)rGrrpatiencerbaselineabs min_deltawait stopped_epochrestore_best_weights best_weightsstart_from_epochrrrcrrrr) r{rrzrwrrrxr}rrhs r.rEarlyStopping.__init__s     Y $8!  0 - - OOJ D 5= ggDO U] jjDO %%e,,<<((44<<((//"$**"$'' ??bjj ( NNa N NNb Nr0cSUlSUlUR[R:Xa[R O[R *UlSUlSUlgrK) r{r|rrcrrrr~ best_epochr0s r.rEarlyStopping.on_train_begin-sB "oo8BFFrvvg  r0c|URU5nUbXR:agUR(a,URcURR 5UlU=R S- slURX0R5(aqX0lXl UR(aURR 5UlURb URX0R5(aSUlgUR UR:aUS:aXl SURl UR(akURb]URS:a'[R "SURS-S35 URR#UR5 ggggg)NrrTz8Restoring model weights from the end of the best epoch: r)get_monitor_valuerr}r~r( get_weightsr{_is_improvementrrrxrwr|r)rr rf set_weights)r{rrMrs r.rEarlyStopping.on_epoch_end5sg((. ?e&;&;;   $ $):):)B $ 6 6 8D  Q    3 3I#O(($(JJ$:$:$<!}}$(<(<))  99 %%!)!& '+DJJ $((T->->-J<URXR- U5$rc)rrz)r{rreference_values r.rEarlyStopping._is_improvementks}~~=OOr0) rxrrr~rzrrrwr}rr|rr{)r=rrrrNFrrc) rirrr r rrrrrrr rYrZs@r.rsrssJ8x "0!d":H PPr0rszkeras.callbacks.RemoteMonitorcD^\rSrSrSrSU4SjjrSSjrSrU=r$) RemoteMonitorioa8Callback used to stream events to a server. Requires the `requests` library. Events are sent to `root + '/publish/epoch/end/'` by default. Calls are HTTP POST, with a `data` argument which is a JSON-encoded dictionary of event data. If `send_as_json=True`, the content type of the request will be `"application/json"`. Otherwise the serialized JSON will be sent within a form. Args: root: String; root url of the target server. path: String; path relative to `root` to which the events will be sent. field: String; JSON field under which the data will be stored. The field is used only if the payload is sent within a form (i.e. send_as_json is set to False). headers: Dictionary; optional custom HTTP headers. send_as_json: Boolean; whether the request should be sent as `"application/json"`. c^>[TU]5 XlX lX0lX@lXPlgrc)rGrrootrfieldheaders send_as_json)r{rrrrrrhs r.rRemoteMonitor.__init__s*     (r0c[c [S5eU=(d 0n0nXS'UR5HLupE[U[R [R 45(aUR5X4'MHXSU'MN UR(a7[R"URUR-X0RS9 g[R"URUR-UR[R"U50URS9 g![R R"a/ [$R&"S[)UR5-5 gf=f)Nz.RemoteMonitor requires the `requests` library.r)jsonr)rz6Warning: could not reach RemoteMonitor root server at )requests ImportErrorrSrrcndarraygenericitemrpostrrrrrdumps exceptionsRequestExceptionrrr)r{rrMsendrTrUs r.rRemoteMonitor.on_epoch_ends  NO OzrW JJLDA!bjj"**566&&(Q!    II )ll II )ZZD!12 LL ""33  OOHdii.!  sAD% AD%%A E21E2)rrrrr)zhttp://localhost:9000z/publish/epoch/end/rENFrc) rirrr r rrr rYrZs@r.rros(.% " ) r0rz%keras.callbacks.LearningRateSchedulercD^\rSrSrSrSU4SjjrSSjrSSjrSrU=r $) LearningRateScheduleriaLearning rate scheduler. At the beginning of every epoch, this callback gets the updated learning rate value from `schedule` function provided at `__init__`, with the current epoch and current learning rate, and applies the updated learning rate on the optimizer. Args: schedule: a function that takes an epoch index (integer, indexed from 0) and current learning rate (float) as inputs and returns a new learning rate as output (float). verbose: int. 0: quiet, 1: update messages. Example: >>> # This function keeps the initial learning rate for the first ten epochs >>> # and decreases it exponentially after that. >>> def scheduler(epoch, lr): ... if epoch < 10: ... return lr ... else: ... return lr * tf.math.exp(-0.1) >>> >>> model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)]) >>> model.compile(tf.keras.optimizers.SGD(), loss='mse') >>> round(model.optimizer.lr.numpy(), 5) 0.01 >>> callback = tf.keras.callbacks.LearningRateScheduler(scheduler) >>> history = model.fit(np.arange(100).reshape(5, 20), np.zeros(5), ... epochs=15, callbacks=[callback], verbose=0) >>> round(model.optimizer.lr.numpy(), 5) 0.00607 c:>[TU]5 XlX lgrc)rGrscheduler)r{rrrhs r.rLearningRateScheduler.__init__s   r0c[URRS5(d [S5e[ [ R "URRR55nURX5n[U[R[[R[R45(d[SU35e[U[R5(a3UR R"(d[SUR 35e[ R$"URRR[ R "U55 UR&S:a![(R*"SUS-SUS 35 gg![a URU5nGN'>?T r0)rrrlrc) rirrr r rrrr rYrZs@r.rrs"H 0@@r0rc[RRR5nSURlSURlUR5n[RRRUSX/5upg[R"S5 [R"U[R S9nSSS5 [RR#UWX#S9sSSS5 $![a!n[R"SU5 SnAgSnAff=f!,(df  Nd=f!,(df  g=f) aPWrites a TF-Keras model as JSON to as a Summary. Writing the TF-Keras model configuration allows the TensorBoard graph plugin to render a conceptual graph, as opposed to graph of ops. In case the model fails to serialize as JSON, it ignores and returns False. Args: name: A name for this summary. The summary tag used for TensorBoard will be this name prefixed by any active name scopes. data: A TF-Keras Model to write. step: Explicit `int64`-castable monotonic step value for this summary. If omitted, this defaults to `tf.summary.experimental.get_step()`, which must not be None. Returns: True on success, or False if no summary was written because no default summary writer was available. Raises: ValueError: if a default writer exists, but no step was provided and `tf.summary.experimental.get_step()` is None. graph_keras_model1z1Model failed to serialize as JSON. Ignoring... %sNFzcpu:0)r)tagtensorrmetadata)rBrCrDSummaryMetadata plugin_data plugin_namecontentto_json ExceptionrrsummaryrE summary_scopedeviceconstantstringwrite) rrErsummary_metadata json_stringexcr_rs r.keras_model_summaryrs.yy||3350C  ,+/  (lln   . . !D<  # YYw [[BII>F zzF      ?     s< C5D4!$D#&D45 D ?DD # D1 -D44 Ezkeras.callbacks.TensorBoardc>^\rSrSrSrS%U4SjjrSrSr\S5r \S5r Sr S r S r S rS rS rSrSrSrS&SjrS&SjrS&SjrS&SjrSrS&SjrS&SjrS&SjrS&SjrSrS&SjrSrSr Sr!Sr"S r#S!r$S"r%S'S#jr&S$r'U=r($)( TensorBoardi/ a1Enable visualizations for TensorBoard. TensorBoard is a visualization tool provided with TensorFlow. This callback logs events for TensorBoard, including: * Metrics summary plots * Training graph visualization * Weight histograms * Sampled profiling When used in `Model.evaluate` or regular validation ([on_test_end](https://www.tensorflow.org/api_docs/python/tf/tf_keras/callbacks/Callback#on_test_end)), in addition to epoch summaries, there will be a summary that records evaluation metrics vs `Model.optimizer.iterations` written. The metric names will be prepended with `evaluation`, with `Model.optimizer.iterations` being the step in the visualized TensorBoard. If you have installed TensorFlow with pip, you should be able to launch TensorBoard from the command line: ``` tensorboard --logdir=path_to_your_logs ``` You can find more information about TensorBoard [here](https://www.tensorflow.org/get_started/summaries_and_tensorboard). Args: log_dir: the path of the directory where to save the log files to be parsed by TensorBoard. e.g. log_dir = os.path.join(working_dir, 'logs') This directory should not be reused by any other callbacks. histogram_freq: frequency (in epochs) at which to compute weight histograms for the layers of the model. If set to 0, histograms won't be computed. Validation data (or split) must be specified for histogram visualizations. write_graph: whether to visualize the graph in TensorBoard. The log file can become quite large when write_graph is set to True. write_images: whether to write model weights to visualize as image in TensorBoard. write_steps_per_second: whether to log the training steps per second into TensorBoard. This supports both epoch and batch frequency logging. update_freq: `'batch'` or `'epoch'` or integer. When using `'epoch'`, writes the losses and metrics to TensorBoard after every epoch. If using an integer, let's say `1000`, all metrics and losses (including custom ones added by `Model.compile`) will be logged to TensorBoard every 1000 batches. `'batch'` is a synonym for `1`, meaning that they will be written every batch. Note however that writing too frequently to TensorBoard can slow down your training, especially when used with `tf.distribute.Strategy` as it will incur additional synchronization overhead. Use with `ParameterServerStrategy` is not supported. Batch-level summary writing is also available via `train_step` override. Please see [TensorBoard Scalars tutorial](https://www.tensorflow.org/tensorboard/scalars_and_keras#batch-level_logging) # noqa: E501 for more details. profile_batch: Profile the batch(es) to sample compute characteristics. profile_batch must be a non-negative integer or a tuple of integers. A pair of positive integers signify a range of batches to profile. By default, profiling is disabled. embeddings_freq: frequency (in epochs) at which embedding layers will be visualized. If set to 0, embeddings won't be visualized. embeddings_metadata: Dictionary which maps embedding layer names to the filename of a file in which to save metadata for the embedding layer. In case the same metadata file is to be used for all embedding layers, a single filename can be passed. Examples: Basic usage: ```python tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir="./logs") model.fit(x_train, y_train, epochs=2, callbacks=[tensorboard_callback]) # Then run the tensorboard command to view the visualizations. ``` Custom batch-level summaries in a subclassed Model: ```python class MyModel(tf.keras.Model): def build(self, _): self.dense = tf.keras.layers.Dense(10) def call(self, x): outputs = self.dense(x) tf.summary.histogram('outputs', outputs) return outputs model = MyModel() model.compile('sgd', 'mse') # Make sure to set `update_freq=N` to log a batch-level summary every N # batches. In addition to any `tf.summary` contained in `Model.call`, # metrics added in `Model.compile` will be logged every N batches. tb_callback = tf.keras.callbacks.TensorBoard('./logs', update_freq=1) model.fit(x_train, y_train, callbacks=[tb_callback]) ``` Custom batch-level summaries in a Functional API Model: ```python def my_summary(x): tf.summary.histogram('x', x) return x inputs = tf.keras.Input(10) x = tf.keras.layers.Dense(10)(inputs) outputs = tf.keras.layers.Lambda(my_summary)(x) model = tf.keras.Model(inputs, outputs) model.compile('sgd', 'mse') # Make sure to set `update_freq=N` to log a batch-level summary every N # batches. In addition to any `tf.summary` contained in `Model.call`, # metrics added in `Model.compile` will be logged every N batches. tb_callback = tf.keras.callbacks.TensorBoard('./logs', update_freq=1) model.fit(x_train, y_train, callbacks=[tb_callback]) ``` Profiling: ```python # Profile a single batch, e.g. the 5th batch. tensorboard_callback = tf.keras.callbacks.TensorBoard( log_dir='./logs', profile_batch=5) model.fit(x_train, y_train, epochs=2, callbacks=[tensorboard_callback]) # Profile a range of batches, e.g. from 10 to 20. tensorboard_callback = tf.keras.callbacks.TensorBoard( log_dir='./logs', profile_batch=(10,20)) model.fit(x_train, y_train, epochs=2, callbacks=[tensorboard_callback]) ``` c  d>[T U]5 SUlURU 5 [R "U5UlX lX0lX@l XPl US:XaSOUUl Xl Xl URU5 SUlSUlSUlSUl0Ul/Ulg)NTrrr)rGrrW_validate_kwargsr rlog_dirhistogram_freq write_graph write_imageswrite_steps_per_second update_freqembeddings_freqembeddings_metadata_init_profile_batch_global_train_batch_previous_epoch_iterations_train_accumulated_timery_writers_prev_summary_state) r{rrrrrr profile_batchrrrrhs r.rTensorBoard.__init__ s !% f%..w7 ,&(&<# +w 61K.#6    /#$ *+''($!" $& r0cURSS5(a[R"S5 URSS5(a[R"S5 URSS5(a[R"S5 URSS5(a[R"S 5 1S kn[UR 55U- nU(a[ S US U35eg )z&Handle arguments were supported in V1. write_gradsFzO`write_grads` will be ignored in TensorFlow 2.0 for the `TensorBoard` Callback.rze`batch_size` is no longer needed in the `TensorBoard` Callback and will be ignored in TensorFlow 2.0.embeddings_layer_nameszp`embeddings_layer_names` is not supported in TensorFlow 2.0. Instead, all `Embedding` layers will be visualized.embeddings_datazl`embeddings_data` is not supported in TensorFlow 2.0. Instead, all `Embedding` variables will be visualized.>rrrrz2Unrecognized arguments in `TensorBoard` Callback: z. Supported kwargs are: N)rRrrrHrr)r{rsupported_kwargsunrecognized_kwargss r.rTensorBoard._validate_kwargs s ::mU + + OO2  ::lE * * OO%  ::. 6 6 OO&  ::' / / OO    "&++-03CC D&'())9(:<  r0cXlUR5Ul[RR URS5UlURRUl[RR URS5Ul URRUl 0Ul SUl UR(aUR5 SUl UR (aUR#5 gg)z2Sets TF-Keras model and writes graph if specified.r validationFTN)r(_get_log_write_dir_log_write_dirrrr/ _train_dirrtrm_val_dirru _val_stepr_should_write_train_graphr_write_keras_model_summaryr_configure_embeddingsrs r.r&TensorBoard.set_model s "557'',,t':':GD::44 T%8%8,G 11 ).&     + + --1D *     & & ( r0cSUR;a6[RRUR5URS'URS$)Nr)rrBrcreate_file_writerrrs r. _train_writerTensorBoard._train_writer sC $-- '%'ZZ%B%B&DMM' "}}W%%r0cSUR;a6[RRUR5URS'URS$)Nval)rrBrrrrs r. _val_writerTensorBoard._val_writer& s>  %#%::#@#@#ODMM% }}U##r0cl[R"URURR5$)zBFor multi-worker, only chief should write, others write to '/tmp'.)r write_dirpathrr(rrs r.rTensorBoard._get_log_write_dir, s(%33 LL$**88  r0cn[R"URURR5 g)z/Deletes tmp write directories for multi-worker.N)rremove_temp_dirpathrr(rrs r._delete_tmp_write_dir!TensorBoard._delete_tmp_write_dir2 s#22 LL$**88 r0cURR5 [RR S5 UR R n[US5(a3[RRURR5 SSS5 SSS5 g!,(df  N=f!,(df  g=f)z:Writes TF-Keras model train_function graph to TensorBoard.T function_specN) r as_defaultrBr record_ifr(train_tf_functionrAgraph_concrete_variable_creation_fn)r{train_fns r._write_keras_model_train_graph*TensorBoard._write_keras_model_train_graph8 s    * * ,%%d+::778_55JJ$$ ??EE ,- ,++- ,s# B8AB'B8' B5 1B88 CcURR5 [RR S5 UR R =(d# UR RRS:HnU(a[SUR SS9 SSS5 SSS5 g!,(df  N=f!,(df  g=f)z5Writes TF-Keras graph network summary to TensorBoard.T SequentialkerasrrN) rr rBrr r(_is_graph_networkrhrir)r{summary_writables r.r&TensorBoard._write_keras_model_summaryD s    * * ,%%d+JJ00Ezz++44 D!$'!D ,- ,++- ,s# B:AB)B:) B7 3B:: CcSSKJn SSKJn SSKJn UR 5nURRHn[XQR5(dMURR5nSnXvl URcMP[UR[5(aURUlMUR"URR%5;dMURR'UR"5UlM UR(aE[UR[5(d&[)SURR%535eUR+U5n[,R.R1UR2S5n [4R6R8R;U S 5n U R=U5 SSS5 g!,(df  g=f) z'Configure the Projector for embeddings.r)core)projector_config_pb2) text_formatz:layer_with_weights-0/embeddings/.ATTRIBUTES/VARIABLE_VALUENzmUnrecognized `Embedding` layer names passed to `keras.callbacks.TensorBoard` `embeddings_metadata` argument: zprojector_config.pbtxtw)tf_keras.src.layersrtf_keras.protobufrgoogle.protobufrProjectorConfigr(layersr Embedding embeddingsadd tensor_namerr metadata_pathrrrrMessageToStringrrr/rrBrrGFiler) r{rrrconfiglayer embeddingr config_pbtxtrfs r.r!TensorBoard._configure_embeddingsO s~ -: 0%557ZZ&&E%00"--113 Q)-%++7!$":":C@@262J2J / ::)A)A)F)F)HH $ 8 8 < [R"TTR-S5$rK)rBequalr)r{rsr.*TensorBoard._push_writer.. s0@0@)@! Dr0rr) rr valuerBrr rr# __enter__)r{writerr should_recordsummary_contexts` ` r. _push_writerTensorBoard._push_writerz s   w & D    djjl + JJ  /    ''8$$&$$&r0cURS:XagURR5nUSR"[R "56 USR"[R "56 g)zPops the current writer.rNrr)rrr__exit__sysexc_info)r{previous_contexts r. _pop_writerTensorBoard._pop_writer s\   w &  33779$$clln5$$clln5r0cfURR5HnUR5 M grc)rvaluesclose)r{r6s r._close_writersTensorBoard._close_writers s"mm**,F LLN-r0cSU3n[U[5(a>[U5RS5n[RR [ U5n[U[ 5(a XlXlOE[U[[45(a[U5S:XaUuUlUlO [U5eURS:dURUR:a [U5eSUl URS:aURSS9 URSS9 SUlURS:H=(a URS:H(+Ulg ) a/Validate profile_batch value and set the range of batches to profile. Sets values of _start_batch and _stop_batch attributes, specifying the start and stop batch to profile. Setting `profile_batch=0` disables profiling. Args: profile_batch: The range of batches to profile. Should be a non-negative integer or a comma separated string of pair of positive integers. A pair of positive integers signify a range of batches to profile. Raises: ValueError: If profile_batch is not an integer or a comma separated pair of positive integers. zprofile_batch must be a non-negative integer or 2-tuple of positive integers. A pair of positive integers signifies a range of batches to profile. Found: rrFrlogdirrN)rrsplitrBrl map_structurer _start_batch _stop_batchtuplerrr_profiler_started_start_profiler_stop_profiler _is_tracing _should_trace)r{rprofile_batch_error_messages r.rTensorBoard._init_profile_batch s=& "#0  2 $ mS ) ) .44S9MGG11#}EM mS ) ) - ,  }udm 4 4]9Kq9P2? /D t/89 9   q D$4$4t7H7H$H89 9 "'   q   +   U  +     " .>?r0cUR5 UR(aUR5 UR5 UR 5 grc)r@rT _stop_tracerErr0s r.rTensorBoard.on_train_end s;          ""$r0cPURURUR5 grc)r9rrr0s r.rTensorBoard.on_test_begin s $**DNN;r0c RURR(a[URRS5(a[RR S5 UR R5 UR5HVup#[RRSU-S-UURRRR5S9 MX SSS5 SSS5 UR5 g!,(df  N'=f!,(df  N0=f)N iterationsT evaluation__vs_iterationsr) r(rrArBrr rr rSscalarr` read_valuer@)r{rMrr4s r.rTensorBoard.on_test_end s ::  GDJJ,@,@,$O$O%%d+T-=-=-H-H-J#'::+>#>!#C   e $   E,@,@$@A$E   '%F r0c[RRSSS9 URURS9 SUlg)NTF)r profilerrI)rBrtrace_onrRrrTrs r.riTensorBoard._start_trace+ s6 $7 DLL1r0clUc URnURR5 [RR S5 [RR SU-US9 SSS5 SSS5 UR5 SUlg!,(df  N.=f!,(df  N7=f)z$Logs the trace graph to TensorBoard.NTzbatch_%d)rrF) rOrr rBrr  trace_exportrSrT)r{rs r.r[TensorBoard._stop_trace0 s =$$E    * * ,%%d+ ''Z%-?e'L,-   ,+- ,s# B% "B,B% B" B%% B3c[URR[R5(a"[ URRSS5nO![ URRSS5n[U[ R 5(a)U"URRR5US'U$)N_learning_rater learning_rate)rr(r OptimizerrXrLearningRateScheduler`)r{rM lr_schedules r._collect_learning_rate"TensorBoard._collect_learning_rate; s djj**I,?,? @ @!$**"6"68H$OK!$**"6"6dCK k#9#N#N O O$/ 0D0D0O0O$PD ! r0cURRRR5n[R"5UR - nXR - U- nU$rc)r(rr`rrrrr)r{current_iterationtime_since_epoch_beginsteps_per_seconds r._compute_steps_per_second%TensorBoard._compute_steps_per_secondD sW JJ00;;AAC!%t/E/E!E  ? ? ? "# r0c hU(dg[5n[5nUR5H%upVURS5(aXdU'M!XcU'M' URU5nUR(aUR 5US'[ RRS5 U(a]URR5 UR5H&upx[ RRSU-XS9 M( SSS5 U(abURR5 UR5H+upxUSSn[ RRSU-XS9 M- SSS5 SSS5 g!,(df  N=f!,(df  N(=f!,(df  g=f)zWrites epoch metrics out as scalar summaries. Args: epoch: Int. The global step to use for TensorBoard. logs: Dict. Keys are scalar summary names, values are scalars. Nr2rTepoch_r) rnrSrrrrrBrr rr rcr) r{rrM train_logsval_logsrTrUrr4s r.ruTensorBoard._log_epoch_metricsL sH V 6JJLDA||F## !1 ! 00<  & &-1-K-K-MJ) * ZZ ! !$ '''224'1'7'7'9  ))(T/5)M(:5%%002'/~~'7 #ABx ))(T/5)M(83 ( '4432 ( 's=*"F# ;F)F#0AF0F# F F# F F## F1c DURR5 [RR S5 UR R HnURHlnURRSS5nUS-n[RRXSUS9 UR(dMUUS-nURX6U5 Mn M URR5 SSS5 SSS5 g!,(df  N=f!,(df  g=f)z-Logs the weights of the Model to TensorBoard.T:rz /histogramrz/imageN)rr rBrr r(r!weightsrreplace histogramr_log_weight_as_imageflush)r{rr*weight weight_namehistogram_weight_nameimage_weight_names r.rvTensorBoard._log_weightsm s    * * ,%%d+!ZZ..E"'--&,kk&9&9#s&C 0;l0J- ,,1- ,,,1'',,    #E7 +  0r0cUR(ag[RRR US9 SUlg![R R a+n[R"SUR5 SnAgSnAff=f)zlStarts the profiler if currently inactive. Args: logdir: Directory where profiler results will be saved. NrITzFailed to start profiler: %s) rQrBrzrEstarterrorsAlreadyExistsErrorrerrormessage)r{rJrs r.rRTensorBoard._start_profiler sk  ! !  E KK $ $ * *& * 9%)D "yy++ E MM8!)) D D Es.AB !!BB c6UR(dg[RRR US9 SUlg![R R a+n[R"SUR5 SnANLSnAff=f!SUlf=f)zlStops the profiler if currently active. Args: save: Whether to save the profiler results to TensorBoard. NrKzFailed to stop profiler: %sF) rQrBrzrEstoprUnavailableErrorrrr)r{rrs r.rSTensorBoard._stop_profiler sy %%  + KK $ $ ) )t ) 4 &+D " yy)) D MM7 C C D&+D "s)'AB !!BBB  B B)ryrrrrTrrrrQrUrrNrOrWrrrmrrrrrrrr(rrrr) rMrTFFrrrNrc)T))rirrr r rrr&propertyrrrrrrrr9r@rErrrrrr_rrrrrir[rrrurvrrwrRrSr rYrZs@r.rr/ sFT$ $&L(T)(&&$$    E)"V ' 6: x@ %< A  41( ! NB+*=01 E++r0rz!keras.callbacks.ReduceLROnPlateauc`^\rSrSrSrS U4SjjrSrS SjrS SjrSr Sr U=r $) ReduceLROnPlateaui adReduce learning rate when a metric has stopped improving. Models often benefit from reducing the learning rate by a factor of 2-10 once learning stagnates. This callback monitors a quantity and if no improvement is seen for a 'patience' number of epochs, the learning rate is reduced. Example: ```python reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=5, min_lr=0.001) model.fit(X_train, Y_train, callbacks=[reduce_lr]) ``` Args: monitor: quantity to be monitored. factor: factor by which the learning rate will be reduced. `new_lr = lr * factor`. patience: number of epochs with no improvement after which learning rate will be reduced. verbose: int. 0: quiet, 1: update messages. mode: one of `{'auto', 'min', 'max'}`. In `'min'` mode, the learning rate will be reduced when the quantity monitored has stopped decreasing; in `'max'` mode it will be reduced when the quantity monitored has stopped increasing; in `'auto'` mode, the direction is automatically inferred from the name of the monitored quantity. min_delta: threshold for measuring the new optimum, to only focus on significant changes. cooldown: number of epochs to wait before resuming normal operation after lr has been reduced. min_lr: lower bound on the learning rate. c  \>[T U]5 XlUS:a[SU35eSU ;a'U R S5n[ R "S5 X lXlX`l X0l X@l Xpl SUl SUlSUlXPlSUlUR%5 g)Nrz8ReduceLROnPlateau does not support a factor >= 1.0. Got epsilonzN`epsilon` argument is deprecated and will be removed, use `min_delta` instead.r)rGrrrrrrfactormin_lrrzrwrcooldowncooldown_counterr{rrr_reset) r{rrrwrrrzrrrrhs r.rReduceLROnPlateau.__init__ s  S=((.x1    9-I OO<   "   !    r0cv^TRS;a([R"STR5 STlTRS:Xd TRS:Xa1STR;a!U4SjTl[ R TlO!U4SjTl[ R *TlSTlSTl g ) z)Resets wait counter and cooldown counter.rzBLearning rate reduction mode %s is unknown, fallback to auto mode.rrrcJ>[R"XTR- 5$rc)rcrrzabr{s r.r2*ReduceLROnPlateau._reset.. s2771$..6H+Ir0cJ>[R"XTR-5$rc)rcrrzrs r.r2r s2::aT^^9K+Lr0rN) rrrrrrcrrrr{rs`r.rReduceLROnPlateau._reset s 992 2 OO)   DI 99  II E$=IDODILDODI ! r0c$UR5 grc)rr0s r.r ReduceLROnPlateau.on_train_begin" s  r0c U=(d 0n[R"URRR5US'UR UR 5nUcI[R"SUR SR[UR5555 gUR5(aU=RS-sl SUlURX0R 5(aX0lSUlgUR5(Gd*U=RS- slURUR":a[R"URRR5nU[$R&"UR(5:aX@R*-n[-XPR(5n[R."URRRU5 UR0S:a [2R4"SUS-SUS35 UR6Ul SUlgggg) NrzgLearning rate reduction is conditioned on metric `%s` which is not available. Available metrics are: %srrrrz.: ReduceLROnPlateau reducing learning rate to r)rrr(rrrRrrrr/rr in_cooldownrr{rrrwrcrrrrrrr rfr)r{rrMrold_lrnew_lrs r.rReduceLROnPlateau.on_epoch_end% szr&&tzz';';'>'>?T ((4<<( ? OOD diik*+  !!%%*% w 22#  %%'' Q 99 -$..tzz/C/C/F/FGF 4;; 77!'++!5!$V[[!9))$***>*>*A*A6J< 15 -$% 8.(r0c URS:$rK)rrs r.rReduceLROnPlateau.in_cooldownJ s$$q((r0) rrrrrzrrrrrwrr{)r=g? rrg-C6?rrrc) rirrr r rrrrrr rYrZs@r.rr sC!J %N(#&J))r0rzkeras.callbacks.CSVLoggercN^\rSrSrSrSU4SjjrS SjrS SjrS SjrSr U=r $) CSVLoggeriN aCallback that streams epoch results to a CSV file. Supports all values that can be represented as a string, including 1D iterables such as `np.ndarray`. Example: ```python csv_logger = CSVLogger('training.log') model.fit(X_train, Y_train, callbacks=[csv_logger]) ``` Args: filename: Filename of the CSV file, e.g. `'run/log.csv'`. separator: String used to separate elements in the CSV file. append: Boolean. True: append if file exists (useful for continuing training). False: overwrite existing file. c>X l[R"U5UlX0lSUlSUlSUl[TU]%5 gr^) sepr rfilenamer#r6r append_headerrGr)r{r separatorr#rhs r.rCSVLogger.__init__c s@ //9    ! r0cUR(a[RRR UR 5(ai[RRR UR S5n[[UR555(+Ul SSS5 SnOSn[RRR UR U5Ul g!,(df  NM=f)Nrrr) r#rBrrr rr(r>rreadlinercsv_file)r{rMr-rs r.rCSVLogger.on_train_beginl s ;;uu{{!!$--00UU[[&&t}}c:a-1#ajjl2C-D)DD&;DD ))$--> ;:s >-C22 Dcb^^^ T=(d 0mSm TRc[TR55TlSnTRHnURS5(dMSn O U(d9TRRTRVs/sHnSU-PM sn5 TR(d{"U4SjS[ R 5nS/TR-n[ R"TRXvS9TlTR(aTRR5 [R"SU05nURU U4S jTR55 TRRU5 TRR5 gs snf) Nc:[U[R5=(a URS:Hn[U[5(aU$[U[ R R5(a*U(d#SSR[[U55S3$U$)Nrz"[z, z]") rrcrndimr collectionsabcIterabler/map)rTis_zero_dim_ndarrays r. handle_value,CSVLogger.on_epoch_end..handle_valuey sp",Q ";"K! !S!!1koo6677+TYYs3{34C88r0Fr2Tc0>\rSrSrYRrSrg)-CSVLogger.on_epoch_end..CustomDialecti r N)rirrr r delimiterr rsr. CustomDialectr s  HH r0rr) fieldnamesdialectc3V># UHoT"TRUS554v M g7f)NAN)rR)rZkeyrrMs r.r\)CSVLogger.on_epoch_end.. s' @I,txxT23 4 s&))rsortedrextendr6csvexcel DictWriterrr writeheaderr OrderedDictrwriterowr) r{rrMval_keys_foundrrTrrrow_dictrs ` ` @r.rCSVLogger.on_epoch_endv sBzr  99 tyy{+DI#Nyy>>&))%)N!"   dii!@i&1*i!@A{{ %  %"TYY.J.. *DK!! '')**GU+;< @D    X& )"AsF,cFURR5 SUlgrc)rrDr6r0s r.rCSVLogger.on_train_end s  r0)r#rrrrrr6)rFrc) rirrr r rrrrr rYrZs@r.rrN s"&?-^r0rzkeras.callbacks.LambdaCallbackc<^\rSrSrSrSU4SjjrSrU=r$)LambdaCallbacki a Callback for creating simple, custom callbacks on-the-fly. This callback is constructed with anonymous functions that will be called at the appropriate time (during `Model.{fit | evaluate | predict}`). Note that the callbacks expects positional arguments, as: - `on_epoch_begin` and `on_epoch_end` expect two positional arguments: `epoch`, `logs` - `on_batch_begin` and `on_batch_end` expect two positional arguments: `batch`, `logs` - `on_train_begin` and `on_train_end` expect one positional argument: `logs` Args: on_epoch_begin: called at the beginning of every epoch. on_epoch_end: called at the end of every epoch. on_batch_begin: called at the beginning of every batch. on_batch_end: called at the end of every batch. on_train_begin: called at the beginning of model training. on_train_end: called at the end of model training. Example: ```python # Print the batch number at the beginning of every batch. batch_print_callback = LambdaCallback( on_batch_begin=lambda batch,logs: print(batch)) # Stream the epoch loss to a file in JSON format. The file content # is not well-formed JSON but rather has a JSON object per line. import json json_log = open('loss_log.json', mode='wt', buffering=1) json_logging_callback = LambdaCallback( on_epoch_end=lambda epoch, logs: json_log.write( json.dumps({'epoch': epoch, 'loss': logs['loss']}) + '\n'), on_train_end=lambda logs: json_log.close() ) # Terminate some processes after having finished model training. processes = ... cleanup_callback = LambdaCallback( on_train_end=lambda logs: [ p.terminate() for p in processes if p.is_alive()]) model.fit(..., callbacks=[batch_print_callback, json_logging_callback, cleanup_callback]) ``` c >[TU]5 URRU5 UbXlUbX lUbX0lUbX@lUbXPlUbX`l ggrc) rGr__dict__rrrrrrr) r{rrrrrrrrhs r.rLambdaCallback.__init__ so  V$  %"0   # ,   %"0   # ,   %"0   # ,  $r0)rrrrrr)NNNNNNrqrZs@r.rr s'1j--r0rrrc)Fr rr7rrrr*r=rrrctensorflow.compat.v2rCv2rB tf_keras.srcrtf_keras.src.distributerrtf_keras.src.optimizersr!tf_keras.src.optimizers.schedulesrtf_keras.src.utilsrr r r tf_keras.src.utils.data_utilsr tf_keras.src.utils.generic_utilsr tf_keras.src.utils.mode_keysrtensorflow.python.platformrrtensorflow.python.utilr tensorflow.python.util.tf_exportrtensorflow.tools.docsrrrrr/r'rGrQrrr"r\r$r rr@deprecated_endpointsrnrsrrrTensorBoardVersionSelectorrrrrr r0r.rsE"K !! :9-D,'',241=.9.    ?J   4.n,-cDcD.cDL ()xExE*xEv *+.=.=,.=b./0X000&-.nLHnL/nLb'($"h$")$"N/0J4hJ41J4Z0R8M?xM?9M?`="E !!3*#3*F*"-.lPHlP/lP^-.CHC/CL56D@HD@7D@N. b+3O +(MDDO +4O +d12H)H)3H)V)*XX+Xv./K-XK-0K-ocHsI II