a Sic(C@sdZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m m ZddlmZddlmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZd d ZGdddeej dZ!Gddde!Z"ddZ#ddZ$ddZ%Gddde!Z&dZ'da(ddZ)Gddde!Z*Gd d!d!e!Z+dd#d$Z,dd&d'Z-dd(d)Z.d*d+Z/dd-d.Z0d/d0Z1d1d2Z2d3d4Z3dd5d6Z4d7d8Z5dd:d;Z6dd?Z8d@dAZ9dBdCZ:ddDdEZ;ddFdGZddLdMZ?ddOdPZ@ddQdRZAdSdTZBddUdVZCdWdXZDddYdZZEd[d\ZFd]d^ZGd_d`ZHddadbZIdcddZJdedfZKdgdhZLdidjZMdkdlZNdmdnZOdodpZPdqdrZQdsdtZRddvdwZSGdxdydyZTdzd{ZUd|d}ZVd~dZWdddZXGdddZYdS)zTraining-related utilities.N)backend) callbacks)losses)metrics) data_utils) generic_utils) losses_utils) tf_inspect) tf_loggingcCs"t|tjjtjjjtjjjjfS)zCReturns true if 'tensor' is a CompositeTensor or a CT Value object.) isinstancetf __internal__CompositeTensorcompatv1SparseTensorValueraggedRaggedTensorValuetensorrZ/var/www/html/django/DPS/env/lib/python3.9/site-packages/keras/engine/training_utils_v1.pyis_composite_or_composite_value)s rc@sFeZdZdZd ddZejddZejd ddZejd d Z dS) AggregatoraAbstract base class used to aggregate batch-level outputs of a loop. Attributes: use_steps: Whether the loop is using `step` or `batch_size`. num_samples: Total number of samples: `batch_size * num_batches`. steps: Total number of steps. batch_size: Batch size. It is used for validation checks between inputs and outputs. results: What to return at the end of the aggregation loop. NcCs"||_||_||_||_g|_dSN) use_steps num_samplessteps batch_sizeresults)selfrrrrrrr__init__Cs zAggregator.__init__cCs tddS)zCreates the initial results from the first batch outputs. Args: batch_outs: A list of batch-level outputs. "Must be implemented in subclasses.NNotImplementedErrorr batch_outsrrrcreateLszAggregator.createcCs tddS)aOAggregates batch-level results into total results. Args: batch_outs: A list of batch-level outputs. batch_start: The start index of this batch. Always `None` if `use_steps` is `True`. batch_end: The end index of this batch. Always `None` if `use_steps` is `True`. r"Nr#r r& batch_start batch_endrrr aggregateUs zAggregator.aggregatecCs tddS)z*Prepares the total results to be returned.r"Nr#r rrrfinalizebszAggregator.finalize)NNN)NN) __name__ __module__ __qualname____doc__r!abcabstractmethodr'r+r-rrrrr7s   r) metaclasscs<eZdZdZd fdd ZddZd ddZd d ZZS) MetricsAggregatora?Aggregator that calculates loss and metrics info. Attributes: use_steps: Whether the loop is using `step` or `batch_size`. num_samples: Total number of samples: `batch_size*num_batches`. steps: Total number of steps, ie number of times to iterate over a dataset to cover all samples. Ncstj|||dddS)Nrrrr)superr!)r rrr __class__rrr!rs zMetricsAggregator.__init__cCsdgt||_dS)N)lenrr%rrrr'zszMetricsAggregator.createcCsV|jr|jd|d7<n|jd|d||7<|dd|jdd<dS)Nr)rrr(rrrr+}szMetricsAggregator.aggregatecCs,|jstd|jd|jp"|j<dS)NzEmpty training data.r)r ValueErrorrrr,rrrr-szMetricsAggregator.finalize)NN)NN r.r/r0r1r!r'r+r- __classcell__rrr8rr5hs   r5cCst|jt|jkr,td|||j|jf|jdd|jddkrptd|||jdd|jddf|jd}|jd}|j}|jD]4}|d|7<t||d}tj||gdd}qtj|j|jfdd}t |j}|d|d<t |}t j j j|||dS)z#Append sparse tensor value objects.zlUnable to concatenate %s and %s. The inner dense shapes do not have the same number of dimensions (%s vs %s)r<Nz`Unable to concatenate %s and %s. The inner dense shapes do not match inner dimensions (%s vs %s)raxis)indicesvalues dense_shape)r;rD RuntimeErrorrBmaxnpappend concatenaterClisttupler rrr)target to_appendbase_dim0_valuemax_dim0_value new_indicesindex new_valuesnew_dense_shaperrr_append_sparse_tensor_values<       rTcCst|jt|jkr$td||f|jdd|jddkrPtd||f|jdd|jd}t|j|}t|jtj j j j rt |j|j}ntj|j|jfdd}tj j j ||S)z#Append ragged tensor value objects.Unable to concatenate %s and %sr<Nrr@)r;shaperE row_splitsrGrHr rCr rrrr_append_ragged_tensor_valuerI)rLrMadjusted_row_splitsnew_row_splitsrRrrrrYs   rYcCst|t|ur(tdt|t|ft|tjrJtjjj||gddSt|tjrhtj ||gddSt|tjjj rt ||St|tjjj j rt||Stdt|dS)aHelper function to append composite tensors to each other in the 0 axis. In order to support batching within a fit/evaluate/predict call, we need to be able to aggregate within a CompositeTensor. Unfortunately, the CT API currently does not make this easy - especially in V1 mode, where we're working with CompositeTensor Value objects that have no connection with the CompositeTensors that created them. Args: target: CompositeTensor or CompositeTensor value object that will be appended to. to_append: CompositeTensor or CompositeTensor value object to append to. 'target'. Returns: A CompositeTensor or CompositeTensor value object. Raises: RuntimeError: if concatenation is not possible. rUr) sp_inputsrAr@z/Attempted to concatenate unsupported object %s.N)typerEr r SparseTensorrr sparse_concat RaggedTensorconcatrrTrrrY)rLrMrrr_append_composite_tensors     rbcs:eZdZdZfddZddZd ddZd d ZZS) ConcatAggregatorzCombine tensor-likes which cannot be merged on the fly. This class expects to aggregate a single tensor-like rather than a nested structure of tensor-likes. csd|_tjddd|ddS)NTr6) compositer7r!)r rr8rrr!szConcatAggregator.__init__cCst||_dSr)rrd)r batch_elementrrrr'szConcatAggregator.createNcCsJ|jr:|j|jdkr:td|j|jf|jdd|j|dS)NruMismatch between expected batch size and model output batch size. Output shape = {}, expected output shape = shape {}r<)rrWr=formatrrH)r rer)r*rrrr+szConcatAggregator.aggregatecCsht|jdkr|jd|_nH|jrR|jd}|jddD]}t||}q:||_ntj|jdd|_dS)Nr<rr@)r;rrdrbrGrI)r rrrrrr--s  zConcatAggregator.finalize)NNr>rrr8rrcs   rccCs$tdur tjtattjtS)zShared threadpool for copying arrays. Pool instantiation takes ~ 2ms, so a singleton pool is used rather than creating a pool per SliceAggregator. Returns: The global copy threadpool. N) _COPY_POOLmultiprocessingpool ThreadPool _COPY_THREADSatexitregistercloserrrr get_copy_poolAs   rrcsHeZdZdZdZdZfddZddZdd Zd d Z d d Z Z S)SliceAggregatoraCombine arrays where the final size is known. This class expects to aggregate a single tensor-like rather than a nested structure of tensor-likes. NumPy copies are an operation that threads handle quite well because all of the heavy lifting is in c and does not need the GIL. Moreover, we can perform lock-free writes to the same buffer in multiple threads because the nature of result aggregation guarantees that either the indices are disjoint or the aggregator will throw an exception in finalize. Moreover, because aggregation is performed on the slowest varying dimension, assignments for a given batch will write to contiguous blocks of memory, further minimizing contention. There is, however, some scheduling and context switching overhead which will offset the gains from pipelining the slice assignment. Below a given threshold it is faster to simply assign in the main thread rather than enqueue the assignment in a side thread. The exact threshold will vary from system to system, but the time is not very sensitive to the exact transition so a value of 2 ** 14 was chosen which should be reasonable on most systems. i@i,cs,g|_t|_g|_tjd|d|ddS)NFr6) _async_copiesrr_pool_errorsr7r!)r rrr8rrr!kszSliceAggregator.__init__cCs0|jf|jdd}|j}tj||d|_dS)Nr<)rWdtype)rrWrwrGemptyr)r rerWrwrrrr'vszSliceAggregator.createcCs|jr|jd|||jkrN|j|jdkrDtd|j|jj||_dSt|j}||jkrt||j||<n.t }|j j |j ||||fd|j|dS)Nrrf)args)rvrrWr=rgrrGprod_BINARY_SIZE_THRESHOLD threadingEventru apply_async _slice_assignrtrH)r rer)r* num_elements is_finishedrrrr+~s(     zSliceAggregator.aggregatec Cs`zPz||j||<Wn0tyD}z|j|WYd}~n d}~00W|n |0dS)z,Legacy utility method to slice input arrays.N)r ExceptionrvrHset)r rer)r*rerrrrs $zSliceAggregator._slice_assigncCsTt}|jD]0}td|jt|g}||stdq|jrP|jddS)Nr:z'Timed out waiting for copy to complete.r)timertrF_MAX_COPY_SECONDSwaitr=rv)r start_timertimeoutrrrr-s   zSliceAggregator.finalize) r.r/r0r1r{rr!r'r+rr-r?rrr8rrsQs  rsc@s.eZdZdZdZddZd ddZddZdS) OutputsAggregatorz%Aggregator that concatenates outputs.NcCstjjdd||_tjj|j|}|D]r}t|rL|jt |j nBt |t j r|j|jrnt |j n t|j|j ntd||jd|q,dS)NcSs t| Sr)rxrrrz*OutputsAggregator.create..z-Attempted to aggregate unsupported object {}.rV)r r nestget_traverse_shallow_structure _structure flatten_up_torrrHrcrr rGndarrayrrsrrErgr')r r&rerrrr's*    zOutputsAggregator.createcCs:tjj|j|}t||jD]\}}||||qdSr)r r rrrziprr+)r r&r)r*reresultrrrr+s zOutputsAggregator.aggregatecCs>|jD] }|qdd|jD|_tj|j|j|_dS)NcSsg|] }|jqSr)r.0irrr rz.OutputsAggregator.finalize..)rr-r rpack_sequence_asr)r rrrrr-s  zOutputsAggregator.finalize)NN)r.r/r0r1rr'r+r-rrrrrs % rTcCs4|r"t|dd}|r&|dd}nd}tj||dS)z Get Progbar. metrics_namesNr<)stateful_metrics)getattrcbks ProgbarLogger)model count_modeinclude_metricsstateful_metric_namesrrr get_progbars rrcCsT|dur |dur td|dt|||r0dSt|ddrPt|djdSdS)a!Determine the number of samples provided for training and evaluation. The number of samples is not defined when running with `steps`, in which case the number of samples is set to `None`. Args: ins: List of tensors to be fed to the Keras function. batch_size: Integer batch size or `None` if not defined. steps: Total number of steps (batches of samples) before declaring `_predict_loop` finished. Ignored with the default value of `None`. steps_name: The public API's parameter name for `steps`. Raises: ValueError: when `steps` is `None` and the attribute `ins.shape` does not exist. Also raises ValueError when `steps` is not `None` and `batch_size` is not `None` because they are mutually exclusive. Returns: When steps is `None`, returns the number of samples to be processed based on the size of the first dimension of the first input numpy array. When steps is not `None` and `batch_size` is `None`, returns `None`. NzIf z' is set, the `batch_size` must be None.rrW)r=check_steps_argumenthasattrintrW)insrr steps_namerrrcheck_num_sampless  rcCs|dur dSt|r|St|tr0td||jdurt|jdkr|dus\t|dkrt|rztj j j |dd}n t |d}|S)zCExpand data of shape (x,) to (x, 1), unless len(expected_shape)==1.Nz7Expected an array data type but received an integer: {}r<r@) rr rr=rgrWr;r is_tensorrr expand_dimsrG)rexpected_shaperrrstandardize_single_array$s(     rcCs t|tjjjr|jS|jSdS)z1Returns the shape of the passed composite tensor.N)r r rrrrDrWrrrrget_composite_shape=src sz t}Wnty"d}Yn0|sL|rHttsHtd|dgSdurjddtt|DSttrzfdd|DWnBty}z*td|jdd t|WYd}~n d}~00ntt t frDtdt t frd dDn>t|d kr4tdt t fr4t gnd dDnjjd krXjng|durddt|DnddDtt|krrtddrtd|dtt|ddt|dttdtdddnt|d krNtd|dtt|dtddn^td krtddstd|dtdddnt|d krt g|r tt|D]H}||durt|r|j}|sqt |} n2t|r,t|}t |} n |j} ||} t| t| krtd|d||dtt| dt| |s| d d} | d d} t| | D]X\} } | | kr| dur| durtd|d||dt| d t| qqS)!acNormalizes inputs and targets provided by users. Users may pass data as a list of arrays, dictionary of arrays, or as a single array. We normalize this to an ordered list of arrays (same order as `names`), while checking that the provided arrays have shapes that match the network's expectations. Args: data: User-provided input data (polymorphic). names: List of expected array names. shapes: Optional list of expected array shapes. check_batch_axis: Boolean; whether to check that the batch axis of the arrays matches the expected value found in `shapes`. exception_prefix: String prefix used for exception formatting. Returns: List of standardized input arrays (one array per model input). Raises: ValueError: in case of improperly formatted user-provided data. NzError when checking model z: expected no data, but got:cSsg|]}dqSrrr_rrrrmrz*standardize_input_data..cs.g|]&}|jjdkr"|jn|qS DataFramer9r.rCrrdatarrrqs zNo data provided for "rz". Need data for each key in: cSsg|]}t|qSr)rGasarray)rdrrrr~rr<cSs"g|]}|jjdkr|jn|qSrrrrrrrsrcSsg|]\}}t||qSrr)rrrWrrrrscSsg|] }t|qSrrrrrrrrrWzr: the list of Numpy arrays that you are passing to your model is not the size the model expected. Expected to see z array(s), z for inputs z' but instead got the following list of z arrays: z...zQ: you are passing a list as input to your model, but the model expects a list of z0 Numpy arrays instead. The list you passed was: zE: data should be a Numpy array, or list/dict of Numpy arrays. Found: zError when checking z : expected z to have z& dimensions, but got array with shape z to have shape z but got array with shape )r; TypeErrorr dictr=rangeKeyErrorrystrrJrKfloatrrGrr9r.rCrrr rrWas_listrr) rnamesshapescheck_batch_axisexception_prefixdata_lenrr tensorshape data_shaperWdimref_dimrrrstandardize_input_dataFs2       "                 rcCsD|dus"t|ttfr0t|dkr0dd|DSt|dkrt|ttfrZt|dkrZ|St|tr~|d|vr~||dgS|gSt|ttfrt|t|krtd|dtt|dtt|d |d |St|tjj r t |||g}|D]}| | |q|Std |d |d t|dS)aMaps `sample_weight` or `class_weight` to model outputs. Args: x_weight: User-provided `sample_weight` or `class_weight` argument. output_names: List of output names (strings) in the model. weight_type: A string used purely for exception printing. Returns: A list of `sample_weight` or `class_weight` where there are exactly one element per model output. Raises: ValueError: In case of invalid user-provided argument. NrcSsg|]}dqSrrrrrrrrz7standardize_sample_or_class_weights..r<z Provided `z` was a list of z elements, but the model has z" outputs. You should provide one `z`array per model output.z$The model has multiple outputs, so `z/` should be either a list or a dict. Provided `z` type not understood: )r rJrKr;rr=r collectionsr2Mappingrcheck_for_unexpected_keysrHgetr)x_weight output_names weight_type x_weightsnamerrr#standardize_sample_or_class_weightssf       rcCs t||dS)N class_weightr)rrrrrstandardize_class_weights%srcCs t||dS)N sample_weightr)rrrrrstandardize_sample_weights+srcsHddfdd}||}||}||}t|dkrRtdtdd|Dt|dkrxtd td d|D|r|rt|d t|d krtd tt|d d tt|d dt|dkrtdtdd|D|rD|rDt|d t|d krDtdtt|d d tt|d ddS)aDoes user input validation for numpy arrays. Args: inputs: list of Numpy arrays of inputs. targets: list of Numpy arrays of targets. weights: list of Numpy arrays of sample weights. Raises: ValueError: in case of incorrectly formatted data. cSst|pt|Sr)r rrrrrris_tensor_or_composite_tensor=sz:check_array_lengths..is_tensor_or_composite_tensorcs&|dur iStfdd|DSdS)Ncs&g|]}|dur|s|jdqS)NrrWryrrrrGsz?check_array_lengths..set_of_lengths..)rrrrrset_of_lengths@s z+check_array_lengths..set_of_lengthsr<zOAll input arrays (x) should have the same number of samples. Got array shapes: cSsg|] }|jqSrrrrrrrUrz'check_array_lengths..zPAll target arrays (y) should have the same number of samples. Got array shapes: cSsg|] }|jqSrrrrrrr[rrzLInput arrays should have the same number of samples as target arrays. Found z input samples and z target samples.zSAll sample_weight arrays should have the same number of samples. Got array shapes: cSsg|] }|jqSrr)rwrrrrhrzRSample_weight arrays should have the same number of samples as target arrays. Got N)r;r=rrJ)inputstargetsweightsrset_xset_yset_wrrrcheck_array_lengths1s^      &rc Cs4tjtjtjh}tjtjtjf}t|||D]\}}}|dus,|dus,t |rTq,t |r|j ddkrt dt |j dt|tj}t||s|r,|j|vr,t|j dd|ddD]j\} } | dur| | kr|j} | dur|r|jnt|} | j} t dt |j dt |d| d qq,dS) aDoes validation on the compatibility of targets and loss functions. This helps prevent users from using loss functions incorrectly. This check is purely for UX purposes. Args: targets: list of Numpy arrays of targets. loss_fns: list of loss functions. output_shapes: list of shapes of model outputs. Raises: ValueError: if a loss function or target array is incompatible with an output. NrVr<z(You are passing a target array of shape a while using as loss `categorical_crossentropy`. `categorical_crossentropy` expects targets to be binary matrices (1s and 0s) of shape (samples, classes). If your targets are integer classes, you can convert them to the expected format via: ``` from keras.utils import to_categorical y_binary = to_categorical(y_int) ``` Alternatively, you can use the loss function `sparse_categorical_crossentropy` instead, which does expect integer targets.zA target array with shape z# was passed for an output of shape z while using as loss `zB`. This loss expects targets to have the same shape as the output.)rmean_squared_errorbinary_crossentropycategorical_crossentropyMeanSquaredErrorBinaryCrossentropyCategoricalCrossentropyrr ris_categorical_crossentropyrWr=rr LossFunctionWrapperfnrr]r.) rloss_fns output_shapes key_loss_fnskey_loss_classesrlossrWis_loss_wrapper target_dimout_dim loss_name loss_typerrr#check_loss_and_target_compatibilityus^   $ rFcCs|sdd|DSt|trtdd|D}|rrt|t|krbtdtt|dt|dd|D}n6t|dkrg}|D]}|d d|Dqn|g}nXt|tjj rt d ||g}|D] } t | | g} || qntd t|g} t|D]x\} }t} |D]V}t||}t||| || d }||_t|tjsntj||d }d|_|| |<q"| | q| S)aqMaps metric names and functions to model outputs. Args: metrics: a list or a list of lists or a dict of metric functions. output_names: a list of the names (strings) of model outputs. output_shapes: a list of the shapes (strings) of model outputs. loss_fns: a list of the loss functions corresponding to the model outputs. from_serialized: whether the model the metrics are being sourced from is being initialized from a serialized format. is_weighted: Boolean indicating whether the given metrics are weighted. Returns: A list (one entry per model output) of dicts. For instance, if the model has 2 outputs, and for the first output we want to compute "binary_accuracy" and "binary_crossentropy", and just "binary_accuracy" for the second output, the list would look like: `[{ 'acc': binary_accuracy(), 'ce': binary_crossentropy(), }, { 'acc': binary_accuracy(), }]` Raises: TypeError: if an incorrect type is passed for the `metrics` argument. cSsg|]}iqSrrrrrrrrz2collect_per_output_metric_info..css|]}t|tVqdSr)r rJrmrrr rz1collect_per_output_metric_info..zdWhen passing a list of lists as `metrics`, it should have one entry per model output. The model has z! outputs, but you passed metrics=cSsg|]}t|qSr)rto_listrrrrrrr<cSsg|]}t|qSr)metrics_module clone_metricrrrrrrrzQType of `metrics` argument not understood. Expected a list or dictionary, found: ) output_shapeloss_fn)rF)r rJanyr;r=rrHrr2rrrrrr enumerate OrderedDictget_metric_nameget_metric_function_from_serializedrMetricMeanMetricWrapper)rrrrfrom_serialized is_weighted any_sub_listnested_metricsrroutput_metricsper_output_metricsr metrics_dictmetric metric_name metric_fnrrrcollect_per_output_metric_infosj#       rcCs^tt||}|||d}|d||}|||f}tj||}t||S)a5Shuffles an array in a batch-wise fashion. Useful for shuffling HDF5 arrays (where one cannot access arbitrary indices). Args: index_array: array of indices to be shuffled. batch_size: integer. Returns: The `index_array` array, shuffled in a batch-wise fashion. N)rr;reshaperGrandomshuffleflattenrH) index_arrayr batch_count last_batchrrr batch_shuffle#s  r!c s:t|tr|d}|dur|dkr|dkr:tdt|tjdkr^tdtjd|durt|jd krtd t|jd n(|durt|jd krtd |j||dur>t|jtjkrtdt|jdttjt|s>jd|j |jkr>td t|jdtjdd}tt rtjd krftdtrZt t }t fdd|D}t t |d }t j|dd<|||<tjjtjd kotd d kfddfdd}tjj||}tj|dt|t}|durtt|t}n}tjd krjd d krt jd d}n"jd d krt jd}t fdd|D}t|t|krt!|} t!} td| | |dur|dur||S|dur(|S|dur6|SdS)aYPerforms sample weight validation and standardization. Everything gets normalized to a single sample-wise (or timestep-wise) weight array. If both `sample_weight` and `class_weight` are provided, the weights are multiplied. Args: y: Numpy array or Tensor of model targets to be weighted. sample_weight: User-provided `sample_weight` argument. class_weight: User-provided `class_weight` argument. sample_weight_mode: One of `None` or `"temporal"`. `"temporal"` indicated that we expect 2D weight data that will be applied to the last 2 dimensions of the targets (i.e. we are weighting timesteps, not samples). Returns: A numpy array of target weights, one entry per sample to weight. Raises: ValueError: In case of invalid user-provided arguments. rN samplewisetemporalz9"sample_weight_mode should be None or "temporal". Found: z4Found a sample_weight array for an input with shape z. Timestep-wise sample weighting (use of sample_weight_mode="temporal") is restricted to outputs that are at least 3D, i.e. that have a time dimension.z'Found a sample_weight array with shape z[. In order to use timestep-wise sample weighting, you should pass a 2D sample_weight array.r<aFound a sample_weight array with shape {}. In order to use timestep-wise sample weights, you should specify sample_weight_mode="temporal" in compile(); founssd "{}" instead. If you just mean to use sample-wise weights, make sure your sample_weight array is 1D.z Found a sample_weight with shapez8.Expected sample_weight with rank less than or equal to z for an input with shape z$. sample_weight cannot be broadcast.z8`class_weight` not supported for 3+ dimensional targets.csg|] }|qSrrrrrrrrz'standardize_weights..cstjddS)Nr<r@)rargmaxrrrrrrz%standardize_weights..csttdtjS)N)rV)r castrrint64rr(rrrrzxInvalid classes or class weights detected. NaN values indicate that an appropriate class weight could not be determined.r@csg|]}|vr|qSrr)rclsr&rrrrzp`class_weight` must contain all classes in the data. The classes %s exist in the data but not in `class_weight`.)"r rKr=rr;rWrgr rndimrrGarraysortedkeyszerosrFnanr smart_condrrrrgather debuggingcheck_numericsr)floatxconvert_to_tensorr'rrr) rrrsample_weight_modeclass_sample_weightr/rC weight_vector y_classesexisting_classesexisting_class_weightr)rrrstandardize_weights;s       $      r>cCstr dSt|S)NF)r executing_eagerly has_tensorslsrrrhas_symbolic_tensorssrCcCsXt|ttfr tdd|DSt|tr@tdd|DSt|oVt|tj S)z&Returns true if `ls` contains tensors.css&|]}t|ot|tj VqdSrr rr r`rvrrrrszhas_tensors..css*|]"\}}t|o t|tj VqdSrrD)rrrFrrrrs) r rJrKrritemsr rr`rArrrr@s r@cCstjjr:t|tr|St|}t|dr4|j S|j S|rBdnd}|dvrj|dvr\d}q|dvrd}n"t|}t|dr|j }n|j }||}|Sd S) zReturns the name corresponding to the given metric input. Args: metric: Metric function name or reference. weighted: Boolean indicating if the given metric is weighted. Returns: The metric name. r weighted_raccuracyacc crossentropycerJrKrK)rLrMrMN) r r tf2enabledr rrrrrr.)rweightedmetric_name_prefixsuffixrrrrrr s"      r cCs|dvrt|St|tjp4t|tjo4|jtjk}t|tjpXt|tjoX|jtj k}|dvr|ddksr|rxtj S|rtj Stj S|ddks|rtj S|rtjStj SdS)a<Returns the metric function corresponding to the given metric input. Args: metric: Metric function name or reference. output_shape: The shape of the output that this metric will be calculated for. loss_fn: The loss function used. Returns: The metric function. rIrNrVr<N)rrr rSparseCategoricalCrossentropyrrsparse_categorical_crossentropyrrbinary_accuracysparse_categorical_accuracycategorical_accuracyr)rrr"is_sparse_categorical_crossentropyis_binary_crossentropyrrrr s.       r cCsr|durPt||j}|dur$|}n,tj||jd}tj||d\}}}||9}|durf||||dS|||dS)z=Invokes metric function and returns the metric result tensor.Nrw)r)r r)rwrsqueeze_or_expand_dimensions)ry_truey_predrmaskrrrrcall_metric_function:s r`cCs|dust|tjr|St|r.zVPlease provide as model inputs either a single array or a list of arrays. You passed: =z)You cannot pass a dictionary as model {}.z[Please provide as model inputs either a single array or a list of arrays. You passed: {}={}N) r rJrKallr=rrrgrGrr r)inporig_inp allow_dict field_namerrrvalidate_input_typess( rrcCs0|durtd|dur td|r,tddS)z2Validates arguments passed when using a generator.Nz`y` argument is not supported when data isa generator or Sequence instance. Instead pass targets as the second element of the generator.z`sample_weight` argument is not supported when data isa generator or Sequence instance. Instead pass sample weights as the third element of the generator.zUIf your data is in the form of a Python generator, you cannot use `validation_split`.ri)rrrjrrrcheck_generator_argumentssrscst|tjjjjtjjf}|dus<|s.zvWhen passing input data as arrays, do not specify `steps_per_epoch`/`steps` argument. Please use `batch_size` instead.F)r r rrrIteratorrCrJr=rgDatasetrGrrKrrrCloggingwarning) input_datarr is_x_iteratorinput_type_strrrurrsF   rcCs<t|tjrt|}|p t}|jjr8tj ||dS|S)Nr[) r rGrr r7rr6rw is_floatingr)rrwrrrcast_single_tensors    rcCszt|rt||djdSg}t||D]J\}}t|tjrHt|}|j|jkrj| t||jdq*| |q*|S)aGReturns target data tensors using correct datatype. Checks that each target and output pair are the same datatype. If not, casts the target to the output's datatype. Args: targets: tensor or list of targets. outputs: tensor or list of outputs. Returns: Targets in appropriate datatype. rr[) r rrrwrr rGrr7rH)routputs new_targetsrLoutrrr#cast_if_floating_dtype_and_mismatchs     rcCstjtjt|d|S)aCasts the given data tensors to the default floating point type. Casts only if the input is already a floating point type. Args: x: tensor or list/tuple of tensors. dtype: The dtype to which Tensors should be cast. Returns: Converted input. r[)r r map_structure functoolspartialrrrrrcast_if_floating_dtype+s rcCs&tjdd|j}tjtj||S)aCasts the given data tensors to the dtypes of the model inputs. Args: x: tensor or list/tuple of tensors. model: The model. Returns: Converted input. Each tensor is casted to the corresponding input in `model.inputs`. cSs|jSrr[)trrrrFrz,cast_to_model_input_dtypes..)r rrrr))rr input_dtypesrrrcast_to_model_input_dtypes;s rcCst|tjjrftd|dd|D|D]8}|s*|j|vrTtd|jdq*| |j|_ q*nt|t t frt |t |krtdtt |dtt |dt||D]\}}|s||_ qn|D]}|s||_ qd S) aPrepares sample weight modes for the model. Args: training_endpoints: List of model _TrainingEndpoints. sample_weight_mode: sample weight mode user input passed from compile API. Raises: ValueError: In case of invalid `sample_weight_mode` input. r8cSsg|] }|jqSr output_namerrrrrrYrz/prepare_sample_weight_modes..zOutput z.missing from `_sample_weight_modes` dictionaryzdWhen passing a list as sample_weight_mode, it should have one entry per model output. The model has z outputs, but you passed z_sample_weight_modes.N)r rr2rrrshould_skip_target_weightsrr=rr8rJrKr;rr)training_endpointsr8 end_pointmodeendpointrrrprepare_sample_weight_modesJsL        rcsttjjr\td|g}|D]4}|vrBtd|d|t |dq$nztt rzfdd|D}n\ttjj rt t |krtdt |tjt }nfddtt |D}|S) aConverts loss to a list of loss functions. Args: loss: String (name of objective function), objective function or `tf.keras.losses.Loss` instance. See `tf.keras.losses`. If the model has multiple outputs, you can use a different loss on each output by passing a dictionary or a list of losses. The loss value that will be minimized by the model will then be the sum of all individual losses. output_names: List of model output names. Returns: A list of loss objective functions. Raises: ValueError: If loss is a dict with keys not in model output names, or if loss is a list with len not equal to model outputs. rzOutput {0} missing from loss dictionary. We assume this was done on purpose. The fit and evaluate APIs will not be expecting any data to be passed to .Ncsg|] }tqSrrhrrrrrrz*prepare_loss_functions..zyWhen passing a list as loss, it should have one entry per model outputs. The model has {} outputs, but you passed loss={}csg|] }tqSrrrrrrrs)r rr2rrrryrzrHrhrrSequencer;r=rgr rrr)rrloss_functionsrrrrprepare_loss_functions|s2   rcCs|dur|D] }d|_q nt|tjjr\td|dd|D|D]}||jd|_qDnjt|t rt |t |krt dt t |dt |t ||D]\}}||_qntdt |d dS) awConverts loss weights to a list of loss weights. The result loss weights will be populated on the training endpoint. Args: training_endpoints: List of model training endpoints. loss_weights: Optional list or dictionary specifying scalar coefficients (Python floats) to weight the loss contributions of different model outputs. The loss value that will be minimized by the model will then be the *weighted sum* of all individual losses, weighted by the `loss_weights` coefficients. If a list, it is expected to have a 1:1 mapping to the model's outputs. If a dict, it is expected to map output names (strings) to scalar coefficients. Raises: ValueError: If loss weight is a dict with key not in model output names, or if loss is a list with len not equal to model outputs. N? loss_weightscSsg|] }|jqSrrrrrrrrz(prepare_loss_weights..z^When passing a list as loss_weights, it should have one entry per model output. The model has z& outputs, but you passed loss_weights=z+Could not interpret loss_weights argument: z - expected a list of dicts.) loss_weightr rr2rrrrrrJr;r=rrr)rrrrrrrprepare_loss_weightss>     rcCs t|ddS)z1Returns whether `layer` is a FeatureLayer or not._is_feature_layerF)r)layerrrris_feature_layersrcCs(to&t|tjjjjtjjtjjfSr)r r?r rrrrxrwrrrris_eager_dataset_or_iterators rcCs6tr|}nt|}tjj |Sr) r r?_as_serialized_graphnumpyr get_valuerrGraphDef FromString)dataset graph_def_strrrrget_dataset_graph_defsrcCstt|tjjsJt|}|jD]}|jdr dSq |jj D]$}|j D]}|jdrJdSqJq@t ddS)zVerifies that the dataset is shuffled. Args: x: Dataset passed as an input to the model. Returns: boolean, whether the input dataset is shuffled or not. ShuffleDatasetTznExpected a shuffled dataset but input dataset `x` is not shuffled. Please invoke `shuffle()` on input dataset.F) r r rrxrnodeop startswithlibraryfunctionnode_defryrz)r graph_defrrrrrverify_dataset_shuffleds       rcCs*t|tjjjjtjjtjjjjtjjfSr)r r rrrrxrwrrrris_dataset_or_iterator s  rcCs6trtjjj|}ntjjj|}t||S)z1Create and initialize an iterator from a dataset.)r r?rrrmake_one_shot_iteratormake_initializable_iteratorinitialize_iterator)riteratorrrr get_iterators rcCs$ts |j}t|f|dSr)r r? initializerr get_sessionrun)rinit_oprrrr#srcCs t|}t|\}}}|||fS)zExtract a tuple of tensors `inputs, targets, sample_weight` from a dataset. Args: dataset: Dataset instance. Returns: Tuple of tensors `x, y, weights`. `y` and `weights` entry may be None. )runpack_iterator_input)rrrrrrrrextract_tensors_from_dataset)s rcCsz |}Wntjjy*tdYn0t|ttfrxt|dvrRt d|t|dkrl|\}}d}q|\}}}n |}d}d}|||fS)zConvert a dataset iterator to a tuple of tensors `x, y, sample_weights`. Args: iterator: Instance of a dataset iterator. Returns: Tuple of tensors `x, y, weights`. `y` and `weights` entry may be None. zkYour dataset iterator ran out of data; Make sure that your dataset can generate required number of samples.)r%r$zPlease provide model inputs as a list or tuple of 2 or 3 elements: (input, target) or (input, target, sample_weights) Received %sr%N) get_nextr errorsOutOfRangeErrorrEr rJrKr;r=)r next_elementrrrrrrr7s*      rr<c Cst|tjjsJ|r6|jjtjjj j kr6dSt tjj |}|tjjjkrn|durntd|f|dkr|dur|||kr|dkrtd|||||||||fntd|||||f|dur|dkr|SdS|S)a;Infers steps_per_epoch needed to loop through a dataset. Args: model: Keras model instance. dataset: Input data of type tf.data.Dataset. steps: Number of steps to draw from the dataset (may be None if unknown). epochs: Number of times to iterate over the dataset. steps_name: The string name of the steps argument, either `steps`, `validation_steps`, or `steps_per_epoch`. Only used for error message formatting. Returns: Integer or `None`. Inferred number of steps to loop through the dataset. `None` is returned if 1) the size of the dataset is unknown and `steps` was not specified, or 2) this is multi-worker training and auto sharding is enabled. Raises: ValueError: In case of invalid argument values. NzQWhen passing an infinitely repeating dataset, you must specify the `%s` argument.rr<zThe dataset you passed contains %s batches, but you passed `epochs=%s` and `%s=%s`, which is a total of %s steps. We cannot draw that many steps from this dataset. We suggest to set `%s=%s`.zThe dataset you passed contains %s batches, but you passed `%s=%s`. We cannot draw that many steps from this dataset. We suggest to set `%s=%s`.)r r rrx_in_multi_worker_modeoptionsexperimental_distributeauto_shard_policy experimentalAutoShardPolicyOFFrr cardinalityINFINITE_CARDINALITYr=)rrrepochsrsizerrrinfer_steps_for_dataset\sN   rc@s:eZdZdZddZddZdddZd d Zd d Zd S) ModelInputszkEncapsulates model inputs. Allows for transforming model inputs while keeping the same structure. cCs||_t|jt|_t|jtttf |_g|_g|_|jrpt |j D]"}|j |j||j |qJn*t j |j|_ddtt|jD|_dS)NcSsg|]}d|dqS)zinput_%dr<rrrrrrsz(ModelInputs.__init__..)_inputsr r_is_dictrJrK_is_single_input_flattened_inputs _input_namesr.r/rHr rrrr;)r rkrrrr!s  zModelInputs.__init__cCs|jS)zReturns keys to name inputs by. In case inputs provided were a list, tuple or single entry, we make up a key 'input_%d'. For dictionary case, we return a sorted list of keys. )rr,rrrget_input_namesszModelInputs.get_input_namesFcCs0tt|j|jD]\}\}}t|tttfrNt |}|j dkrNt |d}t|tj rdt |jdd}|dkr|d}t|j}|jrt}tj|||d}nDt|tjrdt |jdd}|dkrd}tj|||jd}||j|<q|jrtt|j|jS|jr*|s*|jdS|jS)z4Returns inputs to be set as self.inputs for a model.r<rN)Nr<)rWrrwr)rrrrr rJrrrGrr,rrrKrWr as_dtyperwr~rr6 placeholder TensorSpecrrrr)r return_single_as_listrrrFrWrwrrrget_symbolic_inputss4         zModelInputs.get_symbolic_inputsccs&t|j|jD]\}}||fVqdS)z0An iterable over a dictionary version of inputs.N)rrr)r rrFrrras_dictszModelInputs.as_dictcCs|jS)zReturning the inputs as a list.)rr,rrrrszModelInputs.as_listN)F) r.r/r0r1r!rrrrrrrrrs  (rcCsddtt|DS)NcSsg|]}d|dqS)z output_%dr<rrrrrrrz(generic_output_names..)rr;) outputs_listrrrgeneric_output_namessrcCsL|d}t|tr.|dkr"td||dkSt|tjjsDtd||vS)a Checks if validation should be run this epoch. Args: validation_freq: Integer or list. If an integer, specifies how many training epochs to run before a new validation run is performed. If a list, specifies the epochs on which to run validation. epoch: Integer, the number of the training epoch just completed. Returns: Bool, True if validation should be run. Raises: ValueError: if `validation_freq` is an Integer and less than 1, or if it is neither an Integer nor a Sequence. r<z)`validation_freq` can not be less than 1.rz\`validation_freq` must be an Integer or `collections.abc.Container` (e.g. list, tuple, etc.))r rr=rr2 Container)validation_freqepochone_indexed_epochrrrshould_run_validations  rcCst|rtdt|ddr:t|djdd|}ntt|dd|}t|d|t||}}t|d|t||}}|rt|d|t||}}nd}||||||fS)zCSplit input data into train/eval section based on validation_split.zSIf your data is in the form of symbolic tensors, you cannot use `validation_split`.rrWrN)rCr=rrrWr;r slice_arrays)rrsample_weightsrjsplit_atval_xval_yval_sample_weightsrrr"split_training_and_validation_datas&      rcCst|tjjjjtjjtjjtjfs.t |ds<|}d}d}nt |dkr~z|\}}d}Wqt yz|dd}}}Yq0n`t |dkrz|\}}}Wqt y|dd}}}Yq0n |rt d||dd}}}|||fS)a^Unpack validation data based input type. The validation data is not touched if its dataset or dataset iterator. For other type of input (Numpy or tensor), it will be unpacked into tuple of 3 which is x, y and sample weights. Args: validation_data: dataset, dataset iterator, or numpy, tensor tuple. raise_if_ambiguous: boolean on whether to fail if validation_data cannot be parsed. Otherwise simply return validation_data, None, None and defer the decision to the caller. Returns: tuple of 3, (x, y, sample_weights) for numpy and tensor input. __len__Nr%r$zWhen passing a `validation_data` argument, it must contain either 2 items (x_val, y_val), or 3 items (x_val, y_val, val_sample_weights), or alternatively it could be a dataset or a dataset or a dataset iterator. However we received `validation_data=%s`) r r rrrrwrxrrrr;r=)validation_dataraise_if_ambiguousrrval_sample_weightrrrunpack_validation_data<sP      rc@s.eZdZdZd ddZdd d Zdd d ZdS) TrainingLoopa`TrainingLoop is a wrapper class around the training logic. This class is trying to encapsulate the different logic of fit/eval/predict with regard to different data input and model condition. Note that TrainingLoop is stateless, which means it doesn't contain any internal field and can be reused with different model and inputs. Nr<r:TrcKs tdS)z,Train the model with the inputs and targets.Nr#)r rrrrrverboserrjrrrr initial_epochsteps_per_epochvalidation_stepsrkwargsrrrfitszTrainingLoop.fitc Ks tdS)zKReturns the loss value & metrics values for the model in test mode.Nr#) r rrrrrrrrrrrrevaluateszTrainingLoop.evaluatecKs tdSrr#)r rrrrrrrrrrpredicts zTrainingLoop.predict)NNNr<r<Nr:NTNNrNNr<)NNNr<NNN)NrNN)r.r/r0r1rrrrrrrrxs<   r)T)NNr)N)NTr)N)FF)NNN)F)NN)NNN)N)Tr)NNN)N)N)N)r<r)T)Zr1r2rorrmultiprocessing.poolrkr|rrrGtensorflow.compat.v2rv2r kerasrrrrrr keras.utilsrrrr tensorflow.python.platformr ryrobjectABCMetarr5rTrYrbrcrnrjrrrsrrrrrrrrrrrrr!r>rCr@r r r`rhrkrrrsrrrrrrrrrrrrrrrrrrrrrrrrrrrrs         1$54/i8 %  %; DM f  $ - # +  =  20 4  & HW  <