B ӻd@sdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl mZddl mZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlm Z ddl!m"Z"ddl#m$Z$ddl#m%Z%ddl&m'Z'ddl(m)Z)ddl(m*Z*ddl(m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl6m8Z8ddl6m9Z9dd l:m;Z;dd!l:mm?Z@dd#lAmBZCdd$lDmEZEdd%lFmGZGdd&lHmIZIy ddlJZJWneKk r"dZJYnXd'ddddd(d)e3jLfd*d+ZMd'ddddd(e3jLfd,d-ZNd.d/ZOdcd1d2ZPeGd3Gd4d5d5ZQeGd6Gd7d8d8ZReGd9Gd:d;d;eRZSeGd<Gd=d>d>eRZTeGd?Gd@dAdAeRZUeGdBGdCdDdDeRZVeGdEGdFdGdGeRZWeGdHgdIGdJdKdKeRZXeGdLGdMdNdNeRZYeGdOGdPdQdQeRZZeGdRGdSdTdTeRZ[dddUdVZ\eGdWgdIGdXdYdYeRe+j]Z^eGdZGd[d\d\eRZ_eGd]Gd^d_d_eRZ`eGd`GdadbdbeRZadS)ezDCallbacks: utilities called at certain points during model training.N) summary_pb2)checkpoint_management)checkpoint_options) iterator_ops)collective_all_reduce_strategy)distribution_strategy_context)mirrored_strategy)parameter_server_strategy_v2) tpu_strategy)context) constant_op)dtypes)errors)ops)backend)distributed_file_utils)worker_training_state)learning_rate_schedule) generic_utils)tf_utils) version_utils)Sequence)Progbar)path_to_string)ModeKeys)file_io) array_ops)math_ops)summary_ops_v2)gfile) tf_logging) profiler_v2) save_options)nest) keras_export) doc_controlsFstepsc Cst|tr|S|sg}| tjkrRt|_tg|p4g|jg}|rR|t|t|} | } | | t | |||||||| d d| j _ | S)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. 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 ProgbarLoggerZ_get_callback_model set_modelset_callback_parametersmodel stop_training) callbacksr9r(r)r*r+r,r- count_moder. callback_listZcallback_modelr>S/var/www/html/venv/lib/python3.7/site-packages/tensorflow/python/keras/callbacks.pyconfigure_callbacksJs0   r@c Cs|j} x(|D] } t| ttfr | dd| _q Wg} |tjkr^t| } |r^| dd| D7} ||||||| d} || dS)aKSets 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. 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. r&NcSsg|] }d|qS)val_r>).0nr>r>r? sz+set_callback_parameters..)r)r*r'r,r-r(metrics) metrics_namesr/r4r6stateful_metricsrPREDICTcopy set_params) r=r9r(r)r*r+r,r-r. metric_namescbkZcallback_metricsZcallback_paramsr>r>r?r8s"   r8cCs(t|dp&t|dp&t|ttjtjfS)z5Checks if data is a generator, Sequence, or Iterator.__next__next)hasattrr/rrIteratorZ IteratorBase)datar>r>r?_is_generator_likesrRcCsL|j}|tjtjhkr@|r@x,t||D]\}}||||<q&Wn||d<|S)z4Computes logs for sending to `on_batch_end` methods.outputs)rFrr1TESTzip)r9logsrTr.prefixrKlabeloutputr>r>r? make_logss r[zkeras.callbacks.CallbackListc@s&eZdZdZd@ddZddZdAdd Zd d Zd d ZddZ dBddZ ddZ ddZ ddZ ddZddZdCddZdDddZdEd d!ZdFd"d#ZdGd$d%ZdHd&d'ZdId(d)ZdJd*d+ZdKd,d-ZdLd.d/ZdMd0d1ZdNd2d3ZdOd4d5ZdPd6d7ZdQd8d9ZdRd:d;Zdd?Z!dS)Sr0z*Container abstracting a list of callbacks.NFcKs|rt|ng|_||||r.|||r<||tdd|jD|_tdd|jD|_t dd|jD|_ t dd|jD|_ t dd|jD|_ | t dd|jD|_d|_i|_d |_g|_d S) 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`. css|]}t|ddVqdS)_supports_tf_logsFN)getattr)rBcbr>r>r? sz(CallbackList.__init__..css2|]*}|s|s|rt|ddVqdS)r\FN)_implements_train_batch_hooks_implements_test_batch_hooks_implements_predict_batch_hooksr])rBr^r>r>r?r_scss|]}|VqdS)N)r`)rBr^r>r>r?r_scss|]}|VqdS)N)ra)rBr^r>r>r?r_scss|]}|VqdS)N)rb)rBr^r>r>r?r_scss|]}|jjtkVqdS)N) __class____name__globals)rBrLr>r>r?r_sN)r#flattenr;_add_default_callbacksr7rJallr\_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_progbarr9paramsr>r>r?__init__s0   zCallbackList.__init__cCsd|_d|_x0|jD]&}t|tr*||_qt|tr||_qW|jdkrh|rhtdd|_|jd|j|jdkr|rt|_|j|jdS)z)Adds `Callback`s that are always present.Nr')r<r)Z_progbar_historyr;r/r6r2insertr5)rurvrwr^r>r>r?rhs     z#CallbackList._add_default_callbackscCs.|dkr iS|jr|S|r$|jr$|St|S)z?Turns tensors into numpy arrays or Python scalars if necessary.N)r\rjrsync_to_numpy_or_python_type)rurW is_batch_hookr>r>r? _process_logss zCallbackList._process_logscCs|j|dS)N)r;r5)rucallbackr>r>r?r5%szCallbackList.appendcCs$||_x|jD]}||qWdS)N)rxr;rJ)rurxrr>r>r?rJ(s zCallbackList.set_paramscCs2||_|jr|j|_x|jD]}||qWdS)N)r9rzr3r;r7)rur9rr>r>r?r7-s  zCallbackList.set_modelcCsL|js dS|dkr"||||n&|dkr:||||ntd|dS)z4Helper function for all batch_{begin | end} methods.NbeginendzUnrecognized hook: {})r;_call_batch_begin_hook_call_batch_end_hook ValueErrorformat)rur.hookbatchrWr>r>r?_call_batch_hook4szCallbackList._call_batch_hookcCs.dj|d}|||||jr*t|_dS)z/Helper function for `on_*_batch_begin` methods.zon_{mode}_batch_begin)r.N)r_call_batch_hook_helperrptimers)rur.rrW hook_namer>r>r?r@s z#CallbackList._call_batch_begin_hookc Csdj|d}|jr4|dkr4t|j}|j|||||t|j|jkr|}dj|d}t |jt|j}t |j |t|j |} t |j |t|j |} d|} d} | | krt | j||| d| | krt | j||| dd|_d |_g|_i|_ d S) z-Helper function for `on_*_batch_end` methods.zon_{mode}_batch_end)r.r&zon_{mode}_batch_beging?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_timeZ hook_timeFN) rrprrsrtr5rlenrqsumrrloggingwarning) rur.rrWrrZ end_hook_nameZbegin_hook_nameZavg_batch_timeZavg_end_hook_timeZavg_begin_hook_timeZthreshold_timeZ warning_msgr>r>r?rHs:     z!CallbackList._call_batch_end_hookcCsv|jrt}|j|dd}x"|jD]}t||}|||q$W|jrr||jkrZg|j|<|j|t|dS)z+Helper function for `on_*_batch_*` methods.T)r}N)rprr~r;r]rrr5)rurrrW start_timerrr>r>r?rns    z$CallbackList._call_batch_hook_helpercCs4|tjkr|n|tjkr(|n|dS)z:Helper function for on_{train|test|predict}_begin methods.N)rr1on_train_beginrU on_test_beginon_predict_begin)rur.r>r>r?_call_begin_hook}s     zCallbackList._call_begin_hookcCs4|tjkr|n|tjkr(|n|dS)z8Helper function for on_{train|test|predict}_end methods.N)rr1 on_train_endrU on_test_endon_predict_end)rur.r>r>r?_call_end_hooks     zCallbackList._call_end_hookcCs|jr|jtjd||ddS)Nr)rW)rlrrr1)rurrWr>r>r?on_batch_beginszCallbackList.on_batch_begincCs|jr|jtjd||ddS)Nr)rW)rlrrr1)rurrWr>r>r? on_batch_endszCallbackList.on_batch_endcCs*||}x|jD]}|||qWdS)a&Calls 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)r~r;on_epoch_begin)ruepochrWrr>r>r?rs  zCallbackList.on_epoch_begincCs*||}x|jD]}|||qWdS)a`Calls 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)r~r; on_epoch_end)rurrWrr>r>r?rs  zCallbackList.on_epoch_endcCs|jr|jtjd||ddS)aMCalls 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}`. r)rWN)rlrrr1)rurrWr>r>r?on_train_batch_begins z!CallbackList.on_train_batch_begincCs|jr|jtjd||ddS)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. r)rWN)rlrrr1)rurrWr>r>r?on_train_batch_endszCallbackList.on_train_batch_endcCs|jr|jtjd||ddS)aKCalls 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}`. r)rWN)rmrrrU)rurrWr>r>r?on_test_batch_begins z CallbackList.on_test_batch_begincCs|jr|jtjd||ddS)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. r)rWN)rmrrrU)rurrWr>r>r?on_test_batch_endszCallbackList.on_test_batch_endcCs|jr|jtjd||ddS)a9Calls 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. r)rWN)rnrrrH)rurrWr>r>r?on_predict_batch_begins z#CallbackList.on_predict_batch_begincCs|jr|jtjd||ddS)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. r)rWN)rnrrrH)rurrWr>r>r?on_predict_batch_endsz!CallbackList.on_predict_batch_endcCs(||}x|jD]}||qWdS)zCalls the `on_train_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)r~r;r)rurWrr>r>r?rs  zCallbackList.on_train_begincCs(||}x|jD]}||qWdS)zCalls the `on_train_end` 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)r~r;r)rurWrr>r>r?rs  zCallbackList.on_train_endcCs(||}x|jD]}||qWdS)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)r~r;r)rurWrr>r>r?r s  zCallbackList.on_test_begincCs(||}x|jD]}||qWdS)zCalls the `on_test_end` 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)r~r;r)rurWrr>r>r?rs  zCallbackList.on_test_endcCs(||}x|jD]}||qWdS)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)r~r;r)rurWrr>r>r?r"s  zCallbackList.on_predict_begincCs(||}x|jD]}||qWdS)zCalls the `on_predict_end` 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)r~r;r)rurWrr>r>r?r-s  zCallbackList.on_predict_endcCs t|jS)N)iterr;)rur>r>r?__iter__8szCallbackList.__iter__cCsht}|jrdg}x>|jD]4}t|ddr,q|sD|sD|r||qW|rdt d |dS)z>Error out if batch-level callbacks are passed with PSStrategy.r\FziBatch-level `Callback`s are not supported with `ParameterServerStrategy`. Found unsupported callbacks: {}N) ds_contextZ get_strategyZ_should_use_with_coordinatorr;r]r`rarbr5rr)ruZstrategyZunsupported_callbacksr^r>r>r?ro;s  z1CallbackList._disallow_batch_hooks_in_ps_strategy)NFFN)F)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)"rd __module__ __qualname____doc__ryrhr~r5rJr7rrrrrrrrrrrrrrrrrrrrrrrror>r>r>r?r0sD 7  &      r0zkeras.callbacks.Callbackc@speZdZdZddZddZddZeje j d/d d Z eje j d0d d Z ejd1d dZ ejd2ddZeje j d3ddZeje j d4ddZeje j d5ddZeje j d6ddZeje j d7ddZeje j d8ddZejd9ddZejd:dd Zejd;d!d"Zejdd'd(Zd)d*Zd+d,Zd-d.ZdS)?Callbacka]Abstract 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/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 apropriate locations in your loop. Like this: ``` 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). cCsd|_d|_d|_d|_dS)NF)Zvalidation_datar9_chief_worker_onlyr\)rur>r>r?ryszCallback.__init__cCs ||_dS)N)rx)rurxr>r>r?rJszCallback.set_paramscCs ||_dS)N)r9)rur9r>r>r?r7szCallback.set_modelNcCsdS)z;A backwards compatibility alias for `on_train_batch_begin`.Nr>)rurrWr>r>r?rszCallback.on_batch_begincCsdS)z9A backwards compatibility alias for `on_train_batch_end`.Nr>)rurrWr>r>r?rszCallback.on_batch_endcCsdS)aICalled 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>)rurrWr>r>r?rs zCallback.on_epoch_begincCsdS)a Called 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>)rurrWr>r>r?rszCallback.on_epoch_endcCs|j||ddS)a(Called 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, 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}`. )rWN)r)rurrWr>r>r?rszCallback.on_train_batch_begincCs|j||ddS)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. )rWN)r)rurrWr>r>r?rszCallback.on_train_batch_endcCsdS)aCalled 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, 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}`. Nr>)rurrWr>r>r?rszCallback.on_test_batch_begincCsdS)a Called 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>)rurrWr>r>r?rszCallback.on_test_batch_endcCsdS)a Called 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, contains the return value of `model.predict_step`, it typically returns a dict with a key 'outputs' containing the model's outputs. Nr>)rurrWr>r>r?rszCallback.on_predict_batch_begincCsdS)aCalled 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>)rurrWr>r>r?r"szCallback.on_predict_batch_endcCsdS)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>)rurWr>r>r?r2s zCallback.on_train_begincCsdS)aCalled 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>)rurWr>r>r?r=s zCallback.on_train_endcCsdS)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>)rurWr>r>r?rIs zCallback.on_test_begincCsdS)a+Called 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>)rurWr>r>r?rTs zCallback.on_test_endcCsdS)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>)rurWr>r>r?r`s zCallback.on_predict_begincCsdS)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>)rurWr>r>r?rks zCallback.on_predict_endcCs8t|j p6t|j p6t|j p6t|j S)zBDetermines if this Callback should be called for each train batch.)r is_defaultrrrr)rur>r>r?r`vsz&Callback._implements_train_batch_hookscCst|j pt|j S)zADetermines if this Callback should be called for each test batch.)rrrr)rur>r>r?ra}sz%Callback._implements_test_batch_hookscCst|j pt|j S)zDDetermines if this Callback should be called for each predict batch.)rrrr)rur>r>r?rbsz(Callback._implements_predict_batch_hooks)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)N)rdrrrryrJr7r%Zfor_subclass_implementersrdefaultrrrrrrrrrrrrrrrrr`rarbr>r>r>r?rPs^:         rzkeras.callbacks.BaseLoggercs@eZdZdZd fdd Zd ddZd ddZdd d ZZS)r4asCallback that accumulates epoch averages of metrics. This callback is automatically applied to every 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`. Ncs tt|t|pg|_dS)N)superr4rysetrG)rurG)rcr>r?ryszBaseLogger.__init__cCsd|_i|_dS)Nr)seentotals)rurrWr>r>r?rszBaseLogger.on_epoch_begincCs|pi}|dd}|dd}|j||7_xZ|D]N\}}||jkrZ||j|<q<||jkr||j|||7<q<|||j|<qr>r?rs     zBaseLogger.on_batch_endcCsX|dk rTxJ|jdD]<}||jkr||jkr<|j|||<q|j||j||<qWdS)NrE)rxrrGr)rurrWrr>r>r?rs   zBaseLogger.on_epoch_end)N)N)N)N) rdrrrryrrr __classcell__r>r>)rcr?r4s    r4zkeras.callbacks.TerminateOnNaNcs*eZdZdZfddZdddZZS)TerminateOnNaNzDCallback that terminates training when a NaN loss is encountered. cstt|d|_dS)NT)rrryr\)ru)rcr>r?ryszTerminateOnNaN.__init__NcCsP|pi}|d}|dk rLt|}t|s8t|rLtd|d|j_dS)Nlossz,Batch %d: Invalid loss, terminating trainingT) rrr|npisnanisinfprintr9r:)rurrWrr>r>r?rs   zTerminateOnNaN.on_batch_end)N)rdrrrryrrr>r>)rcr?rs rzkeras.callbacks.ProgbarLoggercseZdZdZd*fdd ZddZd+dd Zd,d d Zd-d d Zd.ddZ d/ddZ d0ddZ d1ddZ d2ddZ d3ddZd4ddZddZddZd d!Zd"d#Zd$d%Zd5d&d'Zd(d)ZZS)6r6a,Callback 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,Ncstt|d|_|dkr$d|_n |dkr4d|_ntdt||rPt|nt|_d|_ d|_ d|_ d|_ d|_ d\|_|_|_d|_d|_dS) NTr,Fr'zUnknown `count_mode`: rr&)NNN)rr6ryr\ use_stepsrstrrrGrprogbartargetr-r* _train_step _test_step _predict_step_call_batch_hooks_called_in_fit)rur<rG)rcr>r?rys zProgbarLogger.__init__cCs|d|_|d|_|jr.d|kr.|d|_n |jsHd|krH|d|_nd|_|jdk|_|jdkry"|jj|_|jj|_ |jj |_ Wnt k rd|_YnXdS)Nr-r*r'r,r&T) r-r*rrrr9_train_counterr _test_counterrZ_predict_counterrAttributeError)rurxr>r>r?rJs        zProgbarLogger.set_paramscCs d|_dS)NT)r)rurWr>r>r?rszProgbarLogger.on_train_begincCs|js||dS)N)r_reset_progbar_maybe_init_progbar)rurWr>r>r?r szProgbarLogger.on_test_begincCs||dS)N)rr)rurWr>r>r?rszProgbarLogger.on_predict_begincCs:|||jr6|jdkr6td|d|jfdS)Nr&z Epoch %d/%d)rrr-r*r)rurrWr>r>r?rszProgbarLogger.on_epoch_begincCs|||dS)N)_batch_update_progbar)rurrWr>r>r?rsz ProgbarLogger.on_train_batch_endcCs|js|||dS)N)rr)rurrWr>r>r?rszProgbarLogger.on_test_batch_endcCs||ddS)N)r)rurrWr>r>r?r"sz"ProgbarLogger.on_predict_batch_endcCs|||jdS)N)_finalize_progbarr)rurrWr>r>r?r&szProgbarLogger.on_epoch_endcCs|js|||jdS)N)rrr)rurWr>r>r?r)szProgbarLogger.on_test_endcCs|||jdS)N)rr)rurWr>r>r?r-szProgbarLogger.on_predict_endcCsd|_d|_dS)Nr)rr)rur>r>r?r0szProgbarLogger._reset_progbarcCspt|j|_|jr2|jtdd|jjD|_|jdkr^t|j|j|j|j rTdndd|_|j |jdS)zDInstantiate a `Progbar` if not yet, and update the stateful metrics.css|] }|jVqdS)N)name)rBmr>r>r?r_?sz4ProgbarLogger._maybe_init_progbar..Nstepsample)rr-rGZ unit_name) rrGr9unionrErrrr-rZ_update_stateful_metrics)rur>r>r?r4s  z!ProgbarLogger._maybe_init_progbarcCs|jS)N)r)rur>r>r?r`Jsz+ProgbarLogger._implements_train_batch_hookscCs|jS)N)r)rur>r>r?raMsz*ProgbarLogger._implements_test_batch_hookscCs|jS)N)r)rur>r>r?rbPsz-ProgbarLogger._implements_predict_batch_hookscCs|pi}||jr"|d|_nDt|}|dd}|dd}|dd||}|j|7_|jdkrt|}|jj |jt | dddS) zUpdates the progbar.r&rrrrNF)finalize) rrrrIpopr-rr|rupdatelistr)rurrWr)rZadd_seenr>r>r?rSs       z#ProgbarLogger._batch_update_progbarcCstt|p i}|jdkrT|dk r>|}|js>||dd9}|pF|j|_|j|j_|jj|jt | dddS)Nrr&T)r) rr|rnumpyrrrrrrr)rurWcounterr>r>r?rgs   zProgbarLogger._finalize_progbar)r,N)N)N)N)N)N)N)N)N)N)N)N)rdrrrryrJrrrrrrrrrrrrr`rarbrrrr>r>)rcr?r6s(           r6zkeras.callbacks.Historycs4eZdZdZfddZd ddZd ddZZS) r2amCallback that records events into a `History` object. This callback is automatically applied to every 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']) cstt|i|_dS)N)rr2ryr3)ru)rcr>r?ryszHistory.__init__NcCs g|_dS)N)r)rurWr>r>r?rszHistory.on_train_begincCsJ|pi}|j|x(|D]\}}|j|g|qW||j_dS)N)rr5rr3 setdefaultr9)rurrWrrr>r>r?rs  zHistory.on_epoch_end)N)N)rdrrrryrrrr>r>)rcr?r2ss  r2zkeras.callbacks.ModelCheckpointcseZdZdZd fdd Zd!d d Zd d Zd"ddZd#ddZd$ddZ ddZ ddZ ddZ ddZ ddZddZZS)%ModelCheckpointagCallback to save the 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. 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. **kwargs: Additional arguments for backwards compatibility. Possible key is `period`. val_lossrFautorNc  stt|d|_||_||_t||_||_||_ ||_ d|_ d|_ d|_ |r|dksft|tjrv|ppt|_qtdn,|dkst|tjr|pt|_ntdd| kr| d|_tdnd|_d| kr| d|_td nd |_|d krtd |d }|dkr*tj|_tj|_n\|dkrHtj|_tj |_n>d|jksb|jdrvtj|_tj |_ntj|_tj|_|j dkrt|j t st!d"|j d|_#dS)NTrz`If save_weights_only is True, then `options` must be either None or a tf.train.CheckpointOptionsz`If save_weights_only is False, then `options` must beeither None or a tf.saved_model.SaveOptionsload_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.r&)rminmaxz:ModelCheckpoint mode %s is unknown, fallback to auto mode.rrraccZfmeasurerzUnrecognized save_freq: {})$rrryr\monitorr-rfilepathsave_best_onlysave_weights_only save_freqepochs_since_last_save_batches_seen_since_last_saving_last_batch_seenr/checkpoint_options_libZCheckpointOptions_options TypeErrorsave_options_libZ SaveOptionsrrrrrless monitor_opInfbestgreater startswithintrrr) rurrr-rrr.roptionskwargs)rcr>r?rysZ               zModelCheckpoint.__init__c Csp|jrl||j}|dk rl||rly|j|Wn6ttfk rj}ztd||Wdd}~XYnXdS)Nz&Error loading file from {}. Reason: {}) r1_get_most_recently_modified_file_matching_patternr_checkpoint_existsr9Z load_weightsIOErrorrr)rurWZfilepath_to_loader>r>r?rRs  zModelCheckpoint.on_train_begincCs |jdkS)Nr)r)rur>r>r?r`asz-ModelCheckpoint._implements_train_batch_hookscCs||r|j|j|ddS)N)rrW)_should_save_on_batch _save_model_current_epoch)rurrWr>r>r?res z"ModelCheckpoint.on_train_batch_endcCs ||_dS)N)r)rurrWr>r>r?riszModelCheckpoint.on_epoch_begincCs*|jd7_|jdkr&|j||ddS)Nr&r)rrW)rrr)rurrWr>r>r?rls zModelCheckpoint.on_epoch_endcCsZ|jdkrdS||jkr"|d}n ||j}|j|7_||_|j|jkrVd|_dSdS)z?Handles batch-level saving logic, supports steps_per_execution.rFr&rT)rrr)rurZ add_batchesr>r>r?rrs     z%ModelCheckpoint._should_save_on_batchc Cs|pi}t|jts"|j|jkrt|}d|_|||}y |jr| |j }|dkrnt d|j n| ||jr|jdkrtd|d|j |j||f||_|jr|jj|d|jdn|jj|d|jdn&|jdkrVtd|d|j |jfnR|jdkr$td |d|f|jrB|jj|d|jdn|jj|d|jd|Wn~tk r}ztd |Wdd}~XYnNtk r}z.d t|jdkrtd ||Wdd}~XYnXdS) zSaves the model. Args: epoch: the epoch this iteration is in. logs: the `logs` dict passed in to `on_batch_end` or `on_epoch_end`. rNz5Can save best model only with %s available, skipping.z@ Epoch %05d: %s improved from %0.5f to %0.5f, saving model to %sr&T) overwriterz* Epoch %05d: %s did not improve from %0.5fz Epoch %05d: saving model to %szgPlease specify a non-directory filepath for ModelCheckpoint. Filepath used is an existing directory: {}zis a directory)r/rrrrrr|_get_file_pathrrrrrrrr-rrr9 save_weightsrsave_maybe_remove_fileIsADirectoryErrorrrrargslower)rurrWrcurrentrr>r>r?rsP         zModelCheckpoint._save_modelc Csly|jjfd|di|}Wn4tk rR}ztd|j|Wdd}~XYnXt||jj|_|jS)z%Returns the file path for checkpoint.rr&z9Failed to format this callback filepath: "{}". Reason: {}N)rrKeyErrorrZwrite_filepathr9distribute_strategy_write_filepath)rurrW file_pathrr>r>r?rszModelCheckpoint._get_file_pathcCst|j|jjdS)N)rZremove_temp_dir_with_filepathr r9r )rur>r>r?rsz"ModelCheckpoint._maybe_remove_filecCs4|drt|St|}t|d}|p2|S)z;Returns whether the checkpoint `filepath` refers to exists.z.h5z.index)endswithrfile_exists_v2)rurZtf_saved_model_existsZ!tf_weights_only_checkpoint_existsr>r>r?rs     z"ModelCheckpoint._checkpoint_existsc Cstj|}tj|}dtdd|d}t|}|dk rXt|tj|rX|Sd}d}d}d} t |rxrt |D]d} t|| r~tj || } tj | } | dks| | kr| } | |kr| }| }d}q~| |kr~|d7}q~W|dkr|S| SdS)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&)ospathdirnamebasenameresubrZlatest_checkpointmatchrrlistdirjoingetmtime) rupatterndir_name base_nameZbase_name_regexZlatest_tf_checkpointZlatest_mod_timeZfile_path_with_latest_mod_timeZn_file_with_latest_mod_timeZ file_path_with_largest_file_name file_namer Zmod_timer>r>r?rs8.        zAModelCheckpoint._get_most_recently_modified_file_matching_pattern)rrFFrrN)N)N)N)N)rdrrrryrr`rrrrrrrrrrr>r>)rcr?rs&cJ    = rz-keras.callbacks.experimental.BackupAndRestore)Zv1cs>eZdZdZfddZd ddZd ddZd d d ZZS)BackupAndRestorea Callback to back up and restore the training state. `BackupAndRestore` callback is intended to recover from interruptions that happened in the middle of a model.fit execution by backing up the training states in a temporary checkpoint file (based on TF CheckpointManager) at the end of each epoch. If training restarted before completion, the training state and model are restored to the most recently saved state at the beginning of a new model.fit() run. Note that user is responsible to bring jobs back up. This callback is important for the backup and restore mechanism for fault tolerance purpose. And the model to be restored from an 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 disabling eager execution. 2. A checkpoint is saved at the end of each epoch, when restoring we'll redo any partial work from an unfinished epoch in which the training got restarted (so the work done before a interruption doesn't affect the final model state). 3. This works for both single worker and multi-worker mode, only MirroredStrategy and MultiWorkerMirroredStrategy are supported for now. 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.experimental.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 trainning got interrupted at >>> # zero-indexed epoch 4, second training will continue from 4 to 9. >>> len(history.history['loss']) 6 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 BackupAndRestore callback of another training, or by another callback (ModelCheckpoint) of the same training. cs`tt|||_d|_tjtjt j t j t j f|_tsVtrNtdntdd|_dS)NTz\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.F)rrry backup_dirr\rZMirroredStrategyrZCollectiveAllReduceStrategyr Z TPUStrategyZ TPUStrategyV2r ZParameterServerStrategyV2_supported_strategiesr Zexecuting_eagerlyrZinside_functionrr)rur )rcr>r?ryus  zBackupAndRestore.__init__NcCsZ|jjr.t|jj|js.tdt|jjjt |j|j |j_ |jj |_ |j dS)Nz%s is not supported yet. Currently BackupAndRestore callback only supports empty strategy, MirroredStrategy, MultiWorkerMirroredStrategy and TPUStrategy.) r9Z_distribution_strategyr/r r!NotImplementedErrortyperdrZWorkerTrainingStater _training_staterestore)rurWr>r>r?rs  zBackupAndRestore.on_train_begincCs|j|`|j`dS)N)r$Z delete_backupr9)rurWr>r>r?rs zBackupAndRestore.on_train_endcCs|j|dS)N)r$Zback_up)rurrWr>r>r?rszBackupAndRestore.on_epoch_end)N)N)N) rdrrrryrrrrr>r>)rcr?r;s 8   rzkeras.callbacks.EarlyStoppingcsPeZdZdZdfdd Zdd d Zdd d Zdd dZddZddZ Z S) EarlyStoppinga 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. 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. 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 rrrNFcstt|||_||_||_||_t||_d|_ d|_ ||_ d|_ |dkr`t d|d}|dkrrtj|_n.|dkrtj|_nd|jkrtj|_ntj|_|jtjkr|jd9_n|jd 9_dS) Nr)rrrz8EarlyStopping mode %s is unknown, fallback to auto mode.rrrrr&)rr&ryrpatiencer-baselineabs min_deltawait stopped_epochrestore_best_weights best_weightsrrrrrr)rurr+r(r-r.r)r.)rcr>r?rys0      zEarlyStopping.__init__cCs2d|_d|_|jtjkrtjntj |_d|_dS)Nr)r,r-rrrrrr/)rurWr>r>r?r szEarlyStopping.on_train_begincCs||}|dkrdS|jr2|jdkr2|j|_|jd7_|||jr||_|jrf|j|_|jdks~|||jrd|_|j|j kr||_ d|j_ |jr|jdk r|j dkrt d|j|jdS)Nr&rTz7Restoring model weights from the end of the best epoch.)get_monitor_valuer.r/r9Z get_weightsr,_is_improvementrr)r(r-r:r-rZ set_weights)rurrWrr>r>r?rs&     zEarlyStopping.on_epoch_endcCs*|jdkr&|jdkr&td|jddS)NrzEpoch %05d: early stoppingr&)r-r-r)rurWr>r>r?r-szEarlyStopping.on_train_endc Cs>|pi}||j}|dkr:td|jdt||S)Nz[Early stopping conditioned on metric `%s` which is not available. Available metrics are: %s,)rrrrrrkeys)rurW monitor_valuer>r>r?r01s  zEarlyStopping.get_monitor_valuecCs|||j|S)N)rr+)rur4Zreference_valuer>r>r?r1:szEarlyStopping._is_improvement)rrrrrNF)N)N)N) rdrrrryrrrr0r1rr>r>)rcr?r&s5!    r&zkeras.callbacks.RemoteMonitorcs,eZdZdZd fdd Zd d d ZZS) RemoteMonitoraZCallback 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"`. http://localhost:9000/publish/epoch/end/rQNFcs0tt|||_||_||_||_||_dS)N)rr5ryrootrfieldheaders send_as_json)rur8rr9r:r;)rcr>r?ryUs zRemoteMonitor.__init__cCstdkrtd|pi}i}||d<x<|D]0\}}t|tjtjfrV|||<q.|||<q.WyL|jrtj |j |j ||j dn&tj |j |j |j t|i|j dWn,tjjk rtdt|j YnXdS)Nz.RemoteMonitor requires the `requests` library.r)jsonr:)r:z6Warning: could not reach RemoteMonitor root server at )requests ImportErrorrr/rndarrayZgenericitemr;postr8rr:r9r<dumps exceptionsRequestExceptionrrr)rurrWsendrrr>r>r?rcs$ zRemoteMonitor.on_epoch_end)r6r7rQNF)N)rdrrrryrrr>r>)rcr?r5>s r5z%keras.callbacks.LearningRateSchedulercs6eZdZdZd fdd Zd ddZd dd ZZS) LearningRateScheduleraLearning 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 rcstt|||_||_dS)N)rrFryscheduler-)rurGr-)rcr>r?ryszLearningRateScheduler.__init__NcCst|jjdstdy$tt|jjj}|||}Wnt k rX||}YnXt |t j tt jt jfsztdt |t j r|jjstdt|jjjt||jdkrtd|d|fdS)Nlrz%Optimizer must have a "lr" attribute.z6The output of the "schedule" function should be float.z#The dtype of Tensor should be floatrz? Epoch %05d: LearningRateScheduler setting learning rate to %s.r&)rOr9 optimizerrfloatr get_valuerHrGrr/rZTensorrfloat32Zfloat64dtypeZ is_floating set_valuer-r)rurrWrHr>r>r?rs z$LearningRateScheduler.on_epoch_begincCs |pi}t|jjj|d<dS)NrH)rrKr9rIrH)rurrWr>r>r?rsz"LearningRateScheduler.on_epoch_end)r)N)N)rdrrrryrrrr>r>)rcr?rF}s$ rFc Cst}d|j_d|j_y |}Wn.tk rR}ztd|dSd}~XYnXt |d||g>\}}t dt j|tjd}WdQRXt j||||dSQRXdS) aiWrites a Keras model as JSON to as a Summary. Writing the 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 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. Zgraph_keras_model1z1Model failed to serialize as JSON. Ignoring... %sFNzcpu:0)rM)tagtensorrmetadata)rZSummaryMetadataZ plugin_dataZ plugin_namecontentto_json ExceptionrrrZ summary_scoperZdevicer Zconstantr stringwrite) rrQrZsummary_metadataZ json_stringexcrP_rQr>r>r?keras_model_summarys   rZzkeras.callbacks.TensorBoardc s>eZdZdZdKfd d Zd d Zd dZeddZeddZ ddZ ddZ ddZ ddZ ddZddZdd Zd!d"Zd#d$ZdLd%d&ZdMd'd(ZdNd)d*ZdOd+d,Zd-d.ZdPd/d0ZdQd1d2ZdRd3d4ZdSd5d6Zd7d8ZdTd9d:Zd;d<Zd=d>Zd?d@Z dAdBZ!dCdDZ"dEdFZ#dGdHZ$dUdIdJZ%Z&S)V TensorBoardaEnable visualizations for TensorBoard. TensorBoard is a visualization tool provided with TensorFlow. This callback logs events for TensorBoard, including: * Metrics summary plots * Training graph visualization * Activation histograms * Sampled profiling When used in `Model.evaluate`, 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 activation and 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 `'batch'`, writes the losses and metrics to TensorBoard after each batch. The same applies for `'epoch'`. If using an integer, let's say `1000`, the callback will write the metrics and losses to TensorBoard every 1000 batches. Note that writing too frequently to TensorBoard can slow down your training. 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, it will profile the second batch. Set profile_batch=0 to disable profiling. 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]) ``` rWrTFrNc  stt|d|_|| t||_||_||_||_ ||_ |dkrLdn||_ ||_ | |_ ||d|_d|_d|_d|_i|_g|_dS)NTrr&r)rr[ryr\_validate_kwargsrlog_dirhistogram_freq write_graph write_imageswrite_steps_per_second update_freqembeddings_freqembeddings_metadata_init_profile_batch_global_train_batch_previous_epoch_iterations_train_accumulated_timers_writers_prev_summary_state) rur^r_r`rarbrc profile_batchrdrer)rcr>r?ryos$    zTensorBoard.__init__cCs|ddrtd|ddr,td|ddrBtd|ddrXtd t|ddddh}|rtd t|d S) z&Handle arguments were supported in V1.Z write_gradsFzO`write_grads` will be ignored in TensorFlow 2.0 for the `TensorBoard` Callback.r)ze`batch_size` is no longer needed in the `TensorBoard` Callback and will be ignored in TensorFlow 2.0.Zembeddings_layer_nameszp`embeddings_layer_names` is not supported in TensorFlow 2.0. Instead, all `Embedding` layers will be visualized.Zembeddings_datazl`embeddings_data` is not supported in TensorFlow 2.0. Instead, all `Embedding` variables will be visualized.z2Unrecognized arguments in `TensorBoard` Callback: N)rrrrr3rr)rurZunrecognized_kwargsr>r>r?r]s         zTensorBoard._validate_kwargscCsz||_||_tj|jd|_|jj|_tj|jd|_ |jj |_ i|_ d|_ |jrh|d|_ |jrv|dS)z/Sets Keras model and writes graph if specified.trainZ validationFTN)r9_get_log_write_dir_log_write_dirrrr _train_dirrr_val_dirr _val_steprj_should_write_train_graphr`_write_keras_model_summaryrd_configure_embeddings)rur9r>r>r?r7s   zTensorBoard.set_modelcCs&d|jkrt|j|jd<|jdS)Nrm)rjrcreate_file_writer_v2rp)rur>r>r? _train_writers zTensorBoard._train_writercCs&d|jkrt|j|jd<|jdS)Nval)rjrrvrq)rur>r>r? _val_writers zTensorBoard._val_writercCst|j|jjS)zBFor multi-worker, only chief should write, others write to '/tmp'.)rZ write_dirpathr^r9r )rur>r>r?rnszTensorBoard._get_log_write_dircCst|j|jjdS)z/Deletes tmp write directories for multi-worker.N)rZremove_temp_dirpathr^r9r )rur>r>r?_delete_tmp_write_dirsz!TensorBoard._delete_tmp_write_dirc CsP|j<td&|jj}t|dr8t|jjWdQRXWdQRXdS)z7Writes Keras model train_function graph to TensorBoard.TZ function_specN) rw as_defaultr record_ifr9Ztrain_tf_functionrOgraphZ_concrete_stateful_fn)ruZtrain_fnr>r>r?_write_keras_model_train_graphs    z*TensorBoard._write_keras_model_train_graphc CsZ|jFtd0|jjp,|jjjdk}|rBtd|jddWdQRXWdQRXdS)z2Writes Keras graph network summary to TensorBoard.TZ SequentialZkerasr)rN) rwr{rr|r9Z_is_graph_networkrcrdrZ)ruZsummary_writabler>r>r?rts   z&TensorBoard._write_keras_model_summaryc Csddlm}ddlm}ddlm}|}xp|jjD]d}t ||j r6|j }d}||_ |j dk r6t |j trz|j |_q6|j|j kr6|j |j|_q6W|j rt |j tstdt|j ||}tj|jd} t| d } | |WdQRXdS) z'Configure the Projector for embeddings.r) text_format) embeddings)projector_config_pb2z:layer_with_weights-0/embeddings/.ATTRIBUTES/VARIABLE_VALUENzmUnrecognized `Embedding` layer names passed to `keras.callbacks.TensorBoard` `embeddings_metadata` argument: zprojector_config.pbtxtw)Zgoogle.protobufrZtensorflow.python.keras.layersrZ tensorflow.python.keras.protobufrZProjectorConfigr9layersr/Z EmbeddingaddZ tensor_namererZ metadata_pathrr3rrZMessageToStringrrrrorZOpenrW) rurrrconfiglayerZ embeddingrZ config_pbtxtrfr>r>r?rus,          z!TensorBoard._configure_embeddingscs\jdkrdSfdd}|t|f}j||d|ddS)z9Sets the default writer for custom batch-level summaries.rNcstjdS)Nr)requalrcr>)rurr>r? z*TensorBoard._push_writer..rr&)rcr{valuerr|rkr5 __enter__)ruwriterrZ should_recordZsummary_contextr>)rurr? _push_writer s     zTensorBoard._push_writercCs@|jdkrdS|j}|djt|djtdS)zPops the current writer.rNr&r)rcrkr__exit__sysexc_info)ruZprevious_contextr>r>r? _pop_writer s   zTensorBoard._pop_writercCs x|jD] }|q WdS)N)rjvaluesclose)rurr>r>r?_close_writers& szTensorBoard._close_writerscCsd|}t|tr.t|d}tt|}t|trF||_||_n0t|t t frnt |dkrn|\|_|_nt ||jdks|j|jkrt |d|_ |jdkr|jdd|jddd|_|jdko|jdk |_d S) 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: {}r2r\rFrS)logdir)rN)rr/rsplitr#Z map_structurer _start_batch _stop_batchtuplerrr_profiler_started_start_profiler_stop_profiler _is_tracing _should_trace)rurlZprofile_batch_error_messager>r>r?rf* s&      zTensorBoard._init_profile_batchcCs&d|_d|_d|_||j|jdS)Nr)rgrhrirrwr)rurWr>r>r?r] szTensorBoard.on_train_begincCs*||jr|||dS)N)rr _stop_tracerrz)rurWr>r>r?rc s zTensorBoard.on_train_endcCs||j|jdS)N)rryrr)rurWr>r>r?rl szTensorBoard.on_test_beginc Cs|jjrzt|jjdrztdT|j>x6|D]*\}}tjd|d||jjj dq8WWdQRXWdQRX| dS)N iterationsTZ evaluation_Z_vs_iterations)r) r9rIrOrr|ryr{rscalarrZ read_valuer)rurWrrr>r>r?ro s *zTensorBoard.on_test_endcCs |jp |jS)N)rrb)rur>r>r?r`y sz)TensorBoard._implements_train_batch_hookscCs@|jd7_|jrt|_|js(dS|j|jkr<|dS)Nr&)rgrbrrsrr _start_trace)rurrWr>r>r?r} s  z TensorBoard.on_train_batch_begincCst|jr|d|_|jrLt|j}|j|7_tjdd||jd|j sVdS|j rp|j |j krp| dS)NFZbatch_steps_per_secondg?)r)rsr~rbrrsrirrrrrrgrr)rurrWZbatch_run_timer>r>r?r szTensorBoard.on_train_batch_endcCs |jr|jjj|_d|_dS)Nr)rbr9rIrrrhri)rurrWr>r>r?r szTensorBoard.on_epoch_begincCsL||||jr*||jdkr*|||jrH||jdkrH||dS)z2Runs metrics and histogram summaries at epoch end.rN)_log_epoch_metricsr_ _log_weightsrd_log_embeddings)rurrWr>r>r?r s   zTensorBoard.on_epoch_endcCs&tjddd|j|jdd|_dS)NTF)r}profiler)r)rZtrace_onrrpr)rur>r>r?r szTensorBoard._start_tracec Cs^|dkr|j}|j.tdtjd||dWdQRXWdQRX|d|_dS)z$Logs the trace graph to TensorBoard.NTzbatch_%d)rrF)rrwr{rr|Z trace_exportrr)rurr>r>r?r s  &zTensorBoard._stop_tracecCs2t|jjdd}t|tjr.||jjj|d<|S)NrHZ learning_rate)r]r9rIr/rZLearningRateScheduler)rurWZ lr_scheduler>r>r?_collect_learning_rate s z"TensorBoard._collect_learning_ratecCs"|jjj}||j|j}|S)N)r9rIrrrhri)ruZcurrent_iterationsteps_per_secondr>r>r?_compute_steps_per_second sz%TensorBoard._compute_steps_per_secondc Cs|sdSdd|D}dd|D}||}|jrH||d<td|r|j0x(|D]\}}tjd|||dqnWWdQRX|r|j <x4|D](\}}|d d}tjd|||dqWWdQRXWdQRXdS) 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. NcSs i|]\}}|ds||qS)rA)r)rBrrr>r>r? sz2TensorBoard._log_epoch_metrics..cSs i|]\}}|dr||qS)rA)r)rBrrr>r>r?r srTZepoch_)r) rrrbrrr|rwr{rry)rurrWZ train_logsZval_logsrrr>r>r?r s"    "  zTensorBoard._log_epoch_metricsc Cs|jztddxR|jjD]F}x@|jD]6}|jdd}tj |||d|j r.| |||q.Wq"W|j WdQRXWdQRXdS)z-Logs the weights of the Model to TensorBoard.T:rY)rN) rwr{rr|r9rweightsrreplaceZ histogramra_log_weight_as_imageflush)rurrweight weight_namer>r>r?r s   zTensorBoard._log_weightscCst|}t|}t|dkr:t|d|dddg}nt|dkr|d|dkrjt|}t|}t|d|d|ddg}nVt|dkrtdkrtj|dddgd}t|}t||d|d|ddg}t|}t|dkr|dd krtj |||d d S) z%Logs a weight as a TensorBoard image.r&rr\Z channels_last)Zpermrr')r&rr)rN) rZsqueezerZ int_shaperZreshapeZ transposeZimage_data_formatrimage)rurrrZw_imgshaper>r>r?r s"           z TensorBoard._log_weight_as_imagecCs(tj|jdd|}|j|dS)Nrmzkeras_embedding.ckpt-{})rrrrorr9r)rurZembeddings_ckptr>r>r?r s  zTensorBoard._log_embeddingsc CsX|jr dSytj|dd|_Wn2tjk rR}ztd|jWdd}~XYnXdS)zxStarts the profiler if currently inactive. Args: logdir: Directory where profiler results will be saved. N)rTzFailed to start profiler: %s)rrstartrZAlreadyExistsErrorrerrormessage)rurrr>r>r?r s  zTensorBoard._start_profilerc Cs`|js dSzHytj|dWn2tjk rN}ztd|jWdd}~XYnXWdd|_XdS)zxStops the profiler if currently active. Args: save: Whether to save the profiler results to TensorBoard. N)rzFailed to stop profiler: %sF)rrstoprZUnavailableErrorrrr)rurrr>r>r?r s$zTensorBoard._stop_profiler) rWrTFFrr\rN)N)N)N)N)N)N)N)N)N)T)'rdrrrryr]r7propertyrwryrnrzr~rtrurrrrfrrrrr`rrrrrrrrrrrrrrrr>r>)rcr?r[sT    "  3        r[z!keras.callbacks.ReduceLROnPlateaucsFeZdZdZdfdd Zd d Zdd dZdddZddZZ S)ReduceLROnPlateauaReduce 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. r皙? rr-C6?c  stt|||_|dkr$tdd| kr@| d}td||_||_ ||_ ||_ ||_ ||_ d|_d|_d|_||_d|_|dS)Ng?z3ReduceLROnPlateau does not support a factor >= 1.0.epsilonzN`epsilon` argument is deprecated and will be removed, use `min_delta` instead.r)rrryrrrrrfactormin_lrr+r(r-cooldowncooldown_counterr,rr.r_reset) rurrr(r-r.r+rrr)rcr>r?ryK s&   zReduceLROnPlateau.__init__cs|jdkrtdjd_jdks<jdkrTdjkrTfdd_tj_nfdd_tj _d _d _ d S) z.Resets wait counter and cooldown counter. )rrrzBLearning rate reduction mode %s is unknown, fallback to auto mode.rrrcst||jS)N)rrr+)ab)rur>r?rt rz*ReduceLROnPlateau._reset..cst||jS)N)rrr+)rr)rur>r?rw rrN) r.rrrrrrrrr,)rur>)rur?rk s    zReduceLROnPlateau._resetNcCs |dS)N)r)rurWr>r>r?r| sz ReduceLROnPlateau.on_train_beginc Cs*|pi}t|jjj|d<||j}|dkrPtd|jd t | n| rl|j d8_ d|_|||jr||_d|_n| s&|jd7_|j|jkr&t|jjj}|t|jkr&||j}t||j}t|jjj||jdkrtd|d|f|j|_ d|_dS)NrHzgLearning rate reduction is conditioned on metric `%s` which is not available. Available metrics are: %sr2r&rz< Epoch %05d: ReduceLROnPlateau reducing learning rate to %s.)rrKr9rIrHrrrrrrr3 in_cooldownrr,rrr(rrLrrrrNr-rr)rurrWrZold_lrZnew_lrr>r>r?r s2     zReduceLROnPlateau.on_epoch_endcCs |jdkS)Nr)r)rur>r>r?r szReduceLROnPlateau.in_cooldown)rrrrrrrr)N)N) rdrrrryrrrrrr>r>)rcr?r& s#  rzkeras.callbacks.CSVLoggercs@eZdZdZd fdd ZdddZdd d Zdd d ZZS) CSVLoggera)Callback 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. r2Fcs:||_t||_||_d|_d|_d|_tt| dS)NT) seprfilenamer5rr3 append_headerrrry)rur separatorr5)rcr>r?ry s zCSVLogger.__init__Nc Cs^|jrFt|jr@t|jd}tt| |_ WdQRXd}nd}t|j||_ dS)Nrrr) r5rrrrZGFileboolrreadlinercsv_file)rurWrr.r>r>r?r s zCSVLogger.on_train_begincspiddjdkr(t_jjrHtfddjDjsGfdddtj}dgj}tjj ||d_j rj t d|i}|fd djDj|j dS) NcSsRt|tjo|jdk}t|tr$|St|tjjrJ|sJddt t|S|SdS)Nrz"[%s]"z, ) r/rr?ndimr collectionsabcIterablermap)rZis_zero_dim_ndarrayr>r>r? handle_value s  z,CSVLogger.on_epoch_end..handle_valuec3s*|]"}|kr||fn|dfVqdS)ZNANr>)rBr)rWr>r?r_ sz)CSVLogger.on_epoch_end..cseZdZjZdS)z-CSVLogger.on_epoch_end..CustomDialectN)rdrrr delimiterr>)rur>r? CustomDialect srr) fieldnamesdialectc3s|]}||fVqdS)Nr>)rBkey)rrWr>r?r_ s)r3sortedr9r:dictrcsvexcel DictWriterrr writeheaderr OrderedDictrwriterowr)rurrWrrZrow_dictr>)rrWrur?r s&     zCSVLogger.on_epoch_endcCs|jd|_dS)N)rrr)rurWr>r>r?r s zCSVLogger.on_train_end)r2F)N)N)N) rdrrrryrrrrr>r>)rcr?r s  &rzkeras.callbacks.LambdaCallbackcs"eZdZdZdfdd ZZS)LambdaCallbacka_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]) ``` Nc stt||j||dk r*||_n dd|_|dk rD||_n dd|_|dk r^||_n dd|_|dk rx||_n dd|_|dk r||_ n dd|_ |dk r||_ n dd|_ dS)NcSsdS)Nr>)rrWr>r>r?r7 rz)LambdaCallback.__init__..cSsdS)Nr>)rrWr>r>r?r; rcSsdS)Nr>)rrWr>r>r?r? rcSsdS)Nr>)rrWr>r>r?rC rcSsdS)Nr>)rWr>r>r?rG rcSsdS)Nr>)rWr>r>r?rK r) rrry__dict__rrrrrrr)rurrrrrrr)rcr>r?ry* s(      zLambdaCallback.__init__)NNNNNN)rdrrrryrr>r>)rcr?r s3r)rS)N)brrrIrr<rrrrrrZtensorflow.core.frameworkrZtensorflow.python.checkpointrrrZtensorflow.python.data.opsrZtensorflow.python.distributerrrrr r Ztensorflow.python.eagerr Ztensorflow.python.frameworkr r rrZtensorflow.python.kerasrZ"tensorflow.python.keras.distributerrZ$tensorflow.python.keras.optimizer_v2rZtensorflow.python.keras.utilsrrrZ(tensorflow.python.keras.utils.data_utilsrZ+tensorflow.python.keras.utils.generic_utilsrZ&tensorflow.python.keras.utils.io_utilsrZ'tensorflow.python.keras.utils.mode_keysrZtensorflow.python.lib.iorZtensorflow.python.opsrrrZtensorflow.python.platformrr rZtensorflow.python.profilerr!rZtensorflow.python.saved_modelr"rZtensorflow.python.utilr#Z tensorflow.python.util.tf_exportr$Ztensorflow.tools.docsr%r=r>r1r@r8rRr[r0rr4rr6r2rrr&r5rFrZZTensorBoardVersionSelectorr[rrrr>r>r>r?s                                      7(  :0''"r>A - ={R