B ӻd)@sjdZddlZddlZddlZddlZddlmZddlm Z ddl m Z ddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddlm%Z%ddlm&Z&ddlm'Z'ddlm(Z(ddlm)Z)ddlm*Z*ddl+m,Z,ddl-m.Z.dd l-m/Z/dd!l-m0Z0dd"l1m2Z2dd#l1m3Z3dd$l1m4Z4dd%l5m6Z6dd&l7m8Z8dd'l7m9Z9dd(l7m:Z:dd)l7m;Z;dd*l7mZ?dd-l7m@Z@dd.lAmBZBdd/lAmCZCdd0lDmEZEdd1lFmGZGeEd2Gd3d4d4ejHejId5ZJGd6d7d7eJZKeEd8Gd9d:d:eKZLeEd;GdGd?d@d@eMZNeEdAGdBdCdCeMZOeEdDGdEdFdFeOZPeEdGGdHdIdIeOZQeEdJGdKdLdLeOZReEdMGdNdOdOeOZSeEdPGdQdRdReOZTeEdSGdTdUdUeOZUGdVdWdWeJZVeEdXGdYdZdZeVZWeEd[Gd\d]d]eVZXeEd^Gd_d`d`eVZYeEdaGdbdcdceVZZeEddGdedfdfeJZ[eEdgGdhdidieJZ\GdjdkdkeJejId5Z]eEdlGdmdndne]Z^eEdoGdpdqdqe]Z_eEdrGdsdtdte]Z`eEduGdvdwdwe]ZaeEdxGdydzdzeJZbeEd{Gd|d}d}eOZceEd~GdddeOZdeEdGdddeOZeeEdGdddeOZfeEdGdddeOZgeEdGdddeOZheEdGdddeOZieEdGdddeOZjeEdGdddeMZkeEdGdddeOZleEdGdddeOZmeEdGdddeOZneEdGdddeJZoeEdGdddeJZpeEdGdddeOZqeEdGdddeOZreEdGdddeOZsGdddeKZtGdddetZuddZveEdeBjwdddZxeEdeBjwddZyeEdeBjwddZzeEdeBjwdddZ{eEdƒeBjwdddĄZ|dddDŽZ}evZ~ZeZZe&ZZe$ZZe%ZZe'ZZe}Ze#ZddɄZdd˄ZeEd̃dd΄ZeEdσdddфZeEd҃ddԄZddքZdS)zBuilt-in metrics.N)ag_ctx)api)distribution_strategy_context)context) def_function) constant_op)dtypes)ops) tensor_shape) activations)backend) base_layer)base_layer_utils) keras_tensor)binary_crossentropy)categorical_crossentropy)categorical_hinge)hinge)kullback_leibler_divergence)logcosh)mean_absolute_error)mean_absolute_percentage_error)mean_squared_error)mean_squared_logarithmic_error)poisson)sparse_categorical_crossentropy) squared_hinge)metric_serialization) generic_utils) losses_utils) metrics_utils)deserialize_keras_object)serialize_keras_object)to_list)is_tensor_or_variable) array_ops) check_ops)confusion_matrix)init_ops)math_ops)nn) variables)weights_broadcast_ops)dispatch)nest) keras_export) doc_controlszkeras.metrics.MetriccseZdZdZdfdd ZfddZddZed d Zd d Z d dZ e j ddZ e j ddZejdejjejjddffdd ZeddZeddZeddZejejddZZS)Metrica Encapsulates metric logic and state. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. **kwargs: Additional layer keywords arguments. Standalone usage: ```python m = SomeMetric(...) for input in ...: m.update_state(input) print('Final result: ', m.result().numpy()) ``` Usage with `compile()` API: ```python model = tf.keras.Sequential() model.add(tf.keras.layers.Dense(64, activation='relu')) model.add(tf.keras.layers.Dense(64, activation='relu')) model.add(tf.keras.layers.Dense(10, activation='softmax')) model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01), loss=tf.keras.losses.CategoricalCrossentropy(), metrics=[tf.keras.metrics.CategoricalAccuracy()]) data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.fit(dataset, epochs=10) ``` To be implemented by subclasses: * `__init__()`: All state variables should be created in this method by calling `self.add_weight()` like: `self.var = self.add_weight(...)` * `update_state()`: Has all updates to the state variables like: self.var.assign_add(...). * `result()`: Computes and returns a value for the metric from the state variables. Example subclass implementation: ```python class BinaryTruePositives(tf.keras.metrics.Metric): def __init__(self, name='binary_true_positives', **kwargs): super(BinaryTruePositives, self).__init__(name=name, **kwargs) self.true_positives = self.add_weight(name='tp', initializer='zeros') def update_state(self, y_true, y_pred, sample_weight=None): y_true = tf.cast(y_true, tf.bool) y_pred = tf.cast(y_pred, tf.bool) values = tf.logical_and(tf.equal(y_true, True), tf.equal(y_pred, True)) values = tf.cast(values, self.dtype) if sample_weight is not None: sample_weight = tf.cast(sample_weight, self.dtype) sample_weight = tf.broadcast_to(sample_weight, values.shape) values = tf.multiply(values, sample_weight) self.true_positives.assign_add(tf.reduce_sum(values)) def result(self): return self.true_positives ``` Nc sRtt|jf||d|d|_d|_tsN|dkr@tn t |j |_ dS)N)namedtypeT) superr1__init__ZstatefulZbuiltrZv2_dtype_behavior_enabledr floatxrZas_dtyper2_dtype)selfr2r3kwargs) __class__Q/var/www/html/venv/lib/python3.7/site-packages/tensorflow/python/keras/metrics.pyr5s zMetric.__init__cstt||}ts t|r4|jfdd}n"t|jtj rJ|j}n t |j}t t |||_|jfdd}t t |||_|S)Ncst}t|}|||S)N)rcontrol_status_ctx autograph tf_convert)argsr9control_statusZag_update_state)obj_update_stater;r<update_state_fns z'Metric.__new__..update_state_fncst}t|}|||S)N)rr=r>r?)r@r9rAZ ag_result) obj_resultr;r< result_fns z!Metric.__new__..result_fn)r4r1__new__rZis_in_eager_or_tf_function is_built_in update_state isinstancerFunctionfunctiontypes MethodTyper Zupdate_state_wrapperresultZresult_wrapper)clsr@r9objrCrE)r:)rDrBr<rFs  zMetric.__new__cs*fdd}ddlm}|j|f||S)zAccumulates statistics and then computes metric result value. Args: *args: **kwargs: A mini-batch of inputs to the Metric, passed on to `update_state()`. Returns: The metric value tensor. c sltddt||fDr"d}n j||}g}|dk rD||t|}|_|SQRXdS)z;Updates the state of the metric in a replica-local context.css|]}t|tjVqdS)N)rIrZ KerasTensor).0argr;r;r< sz.replica_local_fn..N) anyr.flattenrHappendr control_dependenciesrNZ _metric_obj)r@r9Z update_opZ update_opsZresult_t)r8r;r<replica_local_fns    z)Metric.__call__..replica_local_fnr)distributed_training_utils)Z"tensorflow.python.keras.distributerYZcall_replica_local_fn)r8r@r9rXrYr;)r8r<__call__s  zMetric.__call__cCs|jS)N)r7)r8r;r;r<r3sz Metric.dtypecCs|j|jdS)z.Returns the serializable config of the metric.)r2r3)r2r3)r8r;r;r< get_configszMetric.get_configcCsBt|js(td|jjf|Stdd|j DdS)zResets all of the metric state variables. This function is called between epochs/steps, when a metric is evaluated during training. zMetric %s implements a `reset_states()` method; rename it to `reset_state()` (without the final "s"). The name `reset_states()` has been deprecated to improve API consistency.cSsg|] }|dfqS)rr;)rQvr;r;r< sz&Metric.reset_state..N) r is_default reset_stateswarningswarnr:__name__r batch_set_valuer+)r8r;r;r< reset_states  zMetric.reset_statecOs tddS)aAccumulates statistics for the metric. Note: This function is executed as a graph function in graph mode. This means: a) Operations on the same resource are executed in textual order. This should make it easier to do things like add the updated value of a variable to another, for example. b) You don't need to worry about collecting the update ops to execute. All update ops added to the graph by this function will be executed. As a result, code should generally work the same way with graph or eager execution. Args: *args: **kwargs: A mini-batch of inputs to the Metric. z"Must be implemented in subclasses.N)NotImplementedError)r8r@r9r;r;r<rHszMetric.update_statecCs tddS)zComputes and returns the metric value tensor. Result computation is an idempotent operation that simply calculates the metric value using the state variables. z"Must be implemented in subclasses.N)re)r8r;r;r<rNsz Metric.resultr;c sjtrt}nd}t|r(tjj}t 0t t |j |||dkrN|j n|d|g||dSQRXdS)z0Adds state variable. Only for use by subclasses.NF)r2shaper3 trainable initializer collectionssynchronization aggregation)distribute_ctxZ has_strategyZ get_strategyr Zis_tpu_strategyvariables_moduleVariableSynchronizationZON_WRITEr init_scoper4r1 add_weightr7)r8r2rfrkrjrhr3Zstrategy)r:r;r<rps     zMetric.add_weightcCs8|jr0|j}x|jD]}||j7}qW||SgSdS)N)rg_trainable_weights_metricstrainable_weights_dedup_weights)r8rsmr;r;r<rs>s   zMetric.trainable_weightscCsX|jr(|j}x@|jD]}||j7}qWn&|j|j}x|jD]}||j7}q>> m = tf.keras.metrics.Sum() >>> m.update_state([1, 3, 5, 7]) >>> m.result().numpy() 16.0 Usage with `compile()` API: ```python model.add_metric(tf.keras.metrics.Sum(name='sum_1')(outputs)) model.compile(optimizer='sgd', loss='mse') ``` sumNcstt|jtjj||ddS)N)rr2r3)r4rr5r rr)r8r2r3)r:r;r<r5sz Sum.__init__)rN)rbryrzr{r5rr;r;)r:r<rsrzkeras.metrics.Meancs"eZdZdZdfdd ZZS)Meana Computes the (weighted) mean of the given values. For example, if values is [1, 3, 5, 7] then the mean is 4. If the weights were specified as [1, 1, 0, 0] then the mean would be 2. This metric creates two variables, `total` and `count` that are used to compute the average of `values`. This average is ultimately returned as `mean` which is an idempotent operation that simply divides `total` by `count`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.Mean() >>> m.update_state([1, 3, 5, 7]) >>> m.result().numpy() 4.0 >>> m.reset_state() >>> m.update_state([1, 3, 5, 7], sample_weight=[1, 1, 0, 0]) >>> m.result().numpy() 2.0 Usage with `compile()` API: ```python model.add_metric(tf.keras.metrics.Mean(name='mean_1')(outputs)) model.compile(optimizer='sgd', loss='mse') ``` meanNcstt|jtjj||ddS)N)rr2r3)r4rr5r rr)r8r2r3)r:r;r<r5s z Mean.__init__)rN)rbryrzr{r5rr;r;)r:r<rs#rzkeras.metrics.MeanRelativeErrorcs<eZdZdZd fdd Zd fdd ZfddZZS) MeanRelativeErrorawComputes the mean relative error by normalizing with the given values. This metric creates two local variables, `total` and `count` that are used to compute the mean relative error. This is weighted by `sample_weight`, and it is ultimately returned as `mean_relative_error`: an idempotent operation that simply divides `total` by `count`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: normalizer: The normalizer values with same shape as predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.MeanRelativeError(normalizer=[1, 3, 2, 3]) >>> m.update_state([1, 3, 2, 3], [2, 4, 6, 8]) >>> # metric = mean(|y_pred - y_true| / normalizer) >>> # = mean([1, 1, 4, 5] / [1, 3, 2, 3]) = mean([1, 1/3, 2, 5/3]) >>> # = 5/4 = 1.25 >>> m.result().numpy() 1.25 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.MeanRelativeError(normalizer=[1, 3])]) ``` Ncs,tt|j||dt||j}||_dS)N)r2r3)r4rr5r)rr7 normalizer)r8rr2r3)r:r;r<r5:szMeanRelativeError.__init__cst||j}t||j}t||g|\\}}}t||\}}t||j\}|_|j |j t t |||j}t t|j||dS)a_Accumulates metric statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Defaults to 1. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Returns: Update op. )r)r)rr7r rrrZremove_squeezable_dimensionsrrfassert_is_compatible_withrabsr4rrH)r8y_truey_predrZrelative_errors)r:r;r<rH?s   zMeanRelativeError.update_statecsJ|j}dt|rt|n|i}tt|}tt| t| S)Nr) rr$r evalr4rr[rritems)r8nconfig base_config)r:r;r<r[]szMeanRelativeError.get_config)NN)N)rbryrzr{r5rHr[rr;r;)r:r<rs$rzkeras.metrics.MeanMetricWrappercsLeZdZdZd fdd Zd fdd ZfddZefd d ZZ S) MeanMetricWrapperaQWraps a stateless metric function with the Mean metric. You could use this class to quickly build a mean metric from a function. The function needs to have the signature `fn(y_true, y_pred)` and return a per-sample loss array. `MeanMetricWrapper.result()` will return the average metric value across all samples seen so far. For example: ```python def accuracy(y_true, y_pred): return tf.cast(tf.math.equal(y_true, y_pred), tf.float32) accuracy_metric = tf.keras.metrics.MeanMetricWrapper(fn=accuracy) keras_model.compile(..., metrics=accuracy_metric) ``` Args: fn: The metric function to wrap, with signature `fn(y_true, y_pred, **kwargs)`. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. **kwargs: Keyword arguments to pass on to `fn`. Nc s$tt|j||d||_||_dS)N)r2r3)r4rr5_fn _fn_kwargs)r8fnr2r3r9)r:r;r<r5szMeanMetricWrapper.__init__cszt||j}t||j}t||g|\\}}}t||\}}t|j t }|||f|j }t t|j||dS)aAccumulates metric statistics. `y_true` and `y_pred` should have the same shape. Args: y_true: Ground truth values. shape = `[batch_size, d0, .. dN]`. y_pred: The predicted values. shape = `[batch_size, d0, .. dN]`. sample_weight: Optional `sample_weight` acts as a coefficient for the metric. If a scalar is provided, then the metric is simply scaled by the given value. If `sample_weight` is a tensor of size `[batch_size]`, then the metric for each sample of the batch is rescaled by the corresponding element in the `sample_weight` vector. If the shape of `sample_weight` is `[batch_size, d0, .. dN-1]` (or can be broadcasted to this shape), then each metric element of `y_pred` is scaled by the corresponding value of `sample_weight`. (Note on `dN-1`: all metric functions reduce by 1 dimension, usually the last axis (-1)). Returns: Update op. )r)r)rr7r rrrr>r?rrr=rr4rrH)r8rrrag_fnmatches)r:r;r<rHs  zMeanMetricWrapper.update_statecsvi}t|tkr|j|d<x0|jD]"\}}t|r@t|n|||<q&Wtt| }t t |t |S)Nr) typerrrrr$r rr4r[rr)r8rkr\r)r:r;r<r[s  zMeanMetricWrapper.get_configcs4|dd}|tkr$|t|f|Stt||S)Nr)poprgetr4 from_config)rOrr)r:r;r<rs zMeanMetricWrapper.from_config)NN)N) rbryrzr{r5rHr[ classmethodrrr;r;)r:r<rds " rzkeras.metrics.Accuracycs"eZdZdZdfdd ZZS)AccuracyaCalculates how often predictions equal labels. This metric creates two local variables, `total` and `count` that are used to compute the frequency with which `y_pred` matches `y_true`. This frequency is ultimately returned as `binary accuracy`: an idempotent operation that simply divides `total` by `count`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.Accuracy() >>> m.update_state([[1], [2], [3], [4]], [[0], [2], [3], [4]]) >>> m.result().numpy() 0.75 >>> m.reset_state() >>> m.update_state([[1], [2], [3], [4]], [[0], [2], [3], [4]], ... sample_weight=[1, 1, 0, 0]) >>> m.result().numpy() 0.5 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.Accuracy()]) ``` accuracyNcstt|jt||ddS)N)r3)r4rr5r)r8r2r3)r:r;r<r5szAccuracy.__init__)rN)rbryrzr{r5rr;r;)r:r<rs$rzkeras.metrics.BinaryAccuracycs"eZdZdZdfdd ZZS)BinaryAccuracyaCalculates how often predictions match binary labels. This metric creates two local variables, `total` and `count` that are used to compute the frequency with which `y_pred` matches `y_true`. This frequency is ultimately returned as `binary accuracy`: an idempotent operation that simply divides `total` by `count`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. threshold: (Optional) Float representing the threshold for deciding whether prediction values are 1 or 0. Standalone usage: >>> m = tf.keras.metrics.BinaryAccuracy() >>> m.update_state([[1], [1], [0], [0]], [[0.98], [1], [0], [0.6]]) >>> m.result().numpy() 0.75 >>> m.reset_state() >>> m.update_state([[1], [1], [0], [0]], [[0.98], [1], [0], [0.6]], ... sample_weight=[1, 0, 0, 1]) >>> m.result().numpy() 0.5 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.BinaryAccuracy()]) ``` binary_accuracyN?cstt|jt|||ddS)N)r3 threshold)r4rr5r)r8r2r3r)r:r;r<r5s zBinaryAccuracy.__init__)rNr)rbryrzr{r5rr;r;)r:r<rs&rz!keras.metrics.CategoricalAccuracycs"eZdZdZdfdd ZZS)CategoricalAccuracyagCalculates how often predictions match one-hot labels. You can provide logits of classes as `y_pred`, since argmax of logits and probabilities are same. This metric creates two local variables, `total` and `count` that are used to compute the frequency with which `y_pred` matches `y_true`. This frequency is ultimately returned as `categorical accuracy`: an idempotent operation that simply divides `total` by `count`. `y_pred` and `y_true` should be passed in as vectors of probabilities, rather than as labels. If necessary, use `tf.one_hot` to expand `y_true` as a vector. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.CategoricalAccuracy() >>> m.update_state([[0, 0, 1], [0, 1, 0]], [[0.1, 0.9, 0.8], ... [0.05, 0.95, 0]]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([[0, 0, 1], [0, 1, 0]], [[0.1, 0.9, 0.8], ... [0.05, 0.95, 0]], ... sample_weight=[0.7, 0.3]) >>> m.result().numpy() 0.3 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.CategoricalAccuracy()]) ``` categorical_accuracyNcstt|jt||ddS)N)r3)r4rr5r)r8r2r3)r:r;r<r5Ds zCategoricalAccuracy.__init__)rN)rbryrzr{r5rr;r;)r:r<rs-rz'keras.metrics.SparseCategoricalAccuracycs"eZdZdZdfdd ZZS)SparseCategoricalAccuracyaCalculates how often predictions match integer labels. ```python acc = np.dot(sample_weight, np.equal(y_true, np.argmax(y_pred, axis=1)) ``` You can provide logits of classes as `y_pred`, since argmax of logits and probabilities are same. This metric creates two local variables, `total` and `count` that are used to compute the frequency with which `y_pred` matches `y_true`. This frequency is ultimately returned as `sparse categorical accuracy`: an idempotent operation that simply divides `total` by `count`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.SparseCategoricalAccuracy() >>> m.update_state([[2], [1]], [[0.1, 0.6, 0.3], [0.05, 0.95, 0]]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([[2], [1]], [[0.1, 0.6, 0.3], [0.05, 0.95, 0]], ... sample_weight=[0.7, 0.3]) >>> m.result().numpy() 0.3 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) ``` sparse_categorical_accuracyNcstt|jt||ddS)N)r3)r4rr5r)r8r2r3)r:r;r<r5ws z"SparseCategoricalAccuracy.__init__)rN)rbryrzr{r5rr;r;)r:r<rIs,rz%keras.metrics.TopKCategoricalAccuracycs"eZdZdZdfdd ZZS)TopKCategoricalAccuracyaiComputes how often targets are in the top `K` predictions. Args: k: (Optional) Number of top elements to look at for computing accuracy. Defaults to 5. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.TopKCategoricalAccuracy(k=1) >>> m.update_state([[0, 0, 1], [0, 1, 0]], ... [[0.1, 0.9, 0.8], [0.05, 0.95, 0]]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([[0, 0, 1], [0, 1, 0]], ... [[0.1, 0.9, 0.8], [0.05, 0.95, 0]], ... sample_weight=[0.7, 0.3]) >>> m.result().numpy() 0.3 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.TopKCategoricalAccuracy()]) ``` top_k_categorical_accuracyNcstt|jt|||ddS)N)r3r)r4rr5r)r8rr2r3)r:r;r<r5s z TopKCategoricalAccuracy.__init__)rrN)rbryrzr{r5rr;r;)r:r<r|s rz+keras.metrics.SparseTopKCategoricalAccuracycs"eZdZdZdfdd ZZS)SparseTopKCategoricalAccuracya Computes how often integer targets are in the top `K` predictions. Args: k: (Optional) Number of top elements to look at for computing accuracy. Defaults to 5. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.SparseTopKCategoricalAccuracy(k=1) >>> m.update_state([2, 1], [[0.1, 0.9, 0.8], [0.05, 0.95, 0]]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([2, 1], [[0.1, 0.9, 0.8], [0.05, 0.95, 0]], ... sample_weight=[0.7, 0.3]) >>> m.result().numpy() 0.3 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.SparseTopKCategoricalAccuracy()]) ``` r!sparse_top_k_categorical_accuracyNcstt|jt|||ddS)N)r3r)r4rr5r)r8rr2r3)r:r;r<r5s z&SparseTopKCategoricalAccuracy.__init__)rrN)rbryrzr{r5rr;r;)r:r<rsrcsHeZdZdZd fdd ZdddZddZd d Zfd d ZZ S)_ConfusionMatrixConditionCountaaCalculates the number of the given confusion matrix condition. Args: confusion_matrix_cond: One of `metrics_utils.ConfusionMatrix` conditions. thresholds: (Optional) Defaults to 0.5. A float value or a python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). One metric value is generated for each threshold value. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Ncs^tt|j||d||_||_tj|dd|_t|j|_ |j dt |jft j d|_dS)N)r2r3g?)default_threshold accumulator)rfrh)r4rr5_confusion_matrix_condinit_thresholdsr parse_init_thresholds thresholds is_evenly_distributed_thresholds_thresholds_distributed_evenlyrplenr(rr)r8confusion_matrix_condrr2r3)r:r;r<r5s  z'_ConfusionMatrixConditionCount.__init__cCs"tj|j|ji|||j|j|dS)acAccumulates the metric statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Defaults to 1. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Returns: Update op. )rthresholds_distributed_evenlyr)r !update_confusion_matrix_variablesrrrr)r8rrrr;r;r<rHs  z+_ConfusionMatrixConditionCount.update_statecCs*t|jdkr|jd}n|j}t|S)Nr)rrrr "convert_to_tensor_v2_with_dispatch)r8rNr;r;r<rNs z%_ConfusionMatrixConditionCount.resultcs,tt|jtfdd|jDdS)Ncsg|]}|tffqSr;)npzeros)rQr\)num_thresholdsr;r<r]sz>_ConfusionMatrixConditionCount.reset_state..)rr#rr rcr+)r8r;)rr<rdsz*_ConfusionMatrixConditionCount.reset_statecs4d|ji}tt|}tt|t|S)Nr)rr4rr[rrr)r8rr)r:r;r<r[ s z)_ConfusionMatrixConditionCount.get_config)NNN)N) rbryrzr{r5rHrNrdr[rr;r;)r:r<rs  rzkeras.metrics.FalsePositivescs"eZdZdZdfdd ZZS)FalsePositivesaCalculates the number of false positives. If `sample_weight` is given, calculates the sum of the weights of false positives. This metric creates one local variable, `accumulator` that is used to keep track of the number of false positives. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: thresholds: (Optional) Defaults to 0.5. A float value or a python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). One metric value is generated for each threshold value. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.FalsePositives() >>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1]) >>> m.result().numpy() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 0, 0], [0, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.FalsePositives()]) ``` Ncs tt|jtjj|||ddS)N)rrr2r3)r4rr5r ConfusionMatrixFALSE_POSITIVES)r8rr2r3)r:r;r<r58s  zFalsePositives.__init__)NNN)rbryrzr{r5rr;r;)r:r<rs'rzkeras.metrics.FalseNegativescs"eZdZdZdfdd ZZS)FalseNegativesaCalculates the number of false negatives. If `sample_weight` is given, calculates the sum of the weights of false negatives. This metric creates one local variable, `accumulator` that is used to keep track of the number of false negatives. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: thresholds: (Optional) Defaults to 0.5. A float value or a python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). One metric value is generated for each threshold value. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.FalseNegatives() >>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0]) >>> m.result().numpy() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [0, 1, 0, 0], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.FalseNegatives()]) ``` Ncs tt|jtjj|||ddS)N)rrr2r3)r4rr5r rFALSE_NEGATIVES)r8rr2r3)r:r;r<r5is  zFalseNegatives.__init__)NNN)rbryrzr{r5rr;r;)r:r<r@s'rzkeras.metrics.TrueNegativescs"eZdZdZdfdd ZZS) TrueNegativesaCalculates the number of true negatives. If `sample_weight` is given, calculates the sum of the weights of true negatives. This metric creates one local variable, `accumulator` that is used to keep track of the number of true negatives. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: thresholds: (Optional) Defaults to 0.5. A float value or a python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). One metric value is generated for each threshold value. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.TrueNegatives() >>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0]) >>> m.result().numpy() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 0, 0], [1, 1, 0, 0], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.TrueNegatives()]) ``` Ncs tt|jtjj|||ddS)N)rrr2r3)r4rr5r rTRUE_NEGATIVES)r8rr2r3)r:r;r<r5s  zTrueNegatives.__init__)NNN)rbryrzr{r5rr;r;)r:r<rqs'rzkeras.metrics.TruePositivescs"eZdZdZdfdd ZZS) TruePositivesaCalculates the number of true positives. If `sample_weight` is given, calculates the sum of the weights of true positives. This metric creates one local variable, `true_positives` that is used to keep track of the number of true positives. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: thresholds: (Optional) Defaults to 0.5. A float value or a python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). One metric value is generated for each threshold value. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.TruePositives() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1]) >>> m.result().numpy() 2.0 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.TruePositives()]) ``` Ncs tt|jtjj|||ddS)N)rrr2r3)r4rr5r rTRUE_POSITIVES)r8rr2r3)r:r;r<r5s  zTruePositives.__init__)NNN)rbryrzr{r5rr;r;)r:r<rs'rzkeras.metrics.PrecisioncsHeZdZdZd fdd ZdddZddZd d Zfd d ZZ S) Precisiona Computes the precision of the predictions with respect to the labels. The metric creates two local variables, `true_positives` and `false_positives` that are used to compute the precision. This value is ultimately returned as `precision`, an idempotent operation that simply divides `true_positives` by the sum of `true_positives` and `false_positives`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `top_k` is set, we'll calculate precision as how often on average a class among the top-k classes with the highest predicted values of a batch entry is correct and can be found in the label for that entry. If `class_id` is specified, we calculate precision by considering only the entries in the batch for which `class_id` is above the threshold and/or in the top-k highest predictions, and computing the fraction of them for which `class_id` is indeed a correct label. Args: thresholds: (Optional) A float value or a python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). One metric value is generated for each threshold value. If neither thresholds nor top_k are set, the default is to calculate precision with `thresholds=0.5`. top_k: (Optional) Unset by default. An int value specifying the top-k predictions to consider when calculating precision. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.Precision() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1]) >>> m.result().numpy() 0.6666667 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 >>> # With top_k=2, it will calculate precision over y_true[:2] and y_pred[:2] >>> m = tf.keras.metrics.Precision(top_k=2) >>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1]) >>> m.result().numpy() 0.0 >>> # With top_k=4, it will calculate precision over y_true[:4] and y_pred[:4] >>> m = tf.keras.metrics.Precision(top_k=4) >>> m.update_state([0, 0, 1, 1], [1, 1, 1, 1]) >>> m.result().numpy() 0.5 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.Precision()]) ``` Ncstt|j||d||_||_||_|dkr2dntj}tj||d|_ t |j |_ |j dt |j ftjd|_|j dt |j ftjd|_dS)N)r2r3g?)rtrue_positives)rfrhfalse_positives)r4rr5rtop_kclass_idr NEG_INFrrrrrprr(rrr)r8rrrr2r3r)r:r;r<r5s     zPrecision.__init__c Cs6tjtjj|jtjj|ji|||j|j|j |j |dS)aAccumulates true positive and false positive statistics. Args: y_true: The ground truth values, with the same dimensions as `y_pred`. Will be cast to `bool`. y_pred: The predicted values. Each element must be in the range `[0, 1]`. sample_weight: Optional weighting of each example. Defaults to 1. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Returns: Update op. )rrrrr) r rrrrrrrrrr)r8rrrr;r;r<rH1s  zPrecision.update_statecCs0t|j|j|j}t|jdkr,|dS|S)Nrr)r)rrrrr)r8rNr;r;r<rNLszPrecision.resultcs2tt|jtfdd|j|jfDdS)Ncsg|]}|tffqSr;)rr)rQr\)rr;r<r]Ssz)Precision.reset_state..)rr#rr rcrr)r8r;)rr<rdQszPrecision.reset_statecs<|j|j|jd}tt|}tt|t|S)N)rrr) rrrr4rr[rrr)r8rr)r:r;r<r[Ws  zPrecision.get_config)NNNNN)N) rbryrzr{r5rHrNrdr[rr;r;)r:r<rsC rzkeras.metrics.RecallcsHeZdZdZd fdd ZdddZddZd d Zfd d ZZ S)RecallaComputes the recall of the predictions with respect to the labels. This metric creates two local variables, `true_positives` and `false_negatives`, that are used to compute the recall. This value is ultimately returned as `recall`, an idempotent operation that simply divides `true_positives` by the sum of `true_positives` and `false_negatives`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `top_k` is set, recall will be computed as how often on average a class among the labels of a batch entry is in the top-k predictions. If `class_id` is specified, we calculate recall by considering only the entries in the batch for which `class_id` is in the label, and computing the fraction of them for which `class_id` is above the threshold and/or in the top-k predictions. Args: thresholds: (Optional) A float value or a python list/tuple of float threshold values in [0, 1]. A threshold is compared with prediction values to determine the truth value of predictions (i.e., above the threshold is `true`, below is `false`). One metric value is generated for each threshold value. If neither thresholds nor top_k are set, the default is to calculate recall with `thresholds=0.5`. top_k: (Optional) Unset by default. An int value specifying the top-k predictions to consider when calculating recall. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.Recall() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1]) >>> m.result().numpy() 0.6666667 >>> m.reset_state() >>> m.update_state([0, 1, 1, 1], [1, 0, 1, 1], sample_weight=[0, 0, 1, 0]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.Recall()]) ``` Ncstt|j||d||_||_||_|dkr2dntj}tj||d|_ t |j |_ |j dt |j ftjd|_|j dt |j ftjd|_dS)N)r2r3g?)rr)rfrhfalse_negatives)r4rr5rrrr rrrrrrprr(rrr)r8rrrr2r3r)r:r;r<r5s     zRecall.__init__c Cs6tjtjj|jtjj|ji|||j|j|j |j |dS)aAccumulates true positive and false negative statistics. Args: y_true: The ground truth values, with the same dimensions as `y_pred`. Will be cast to `bool`. y_pred: The predicted values. Each element must be in the range `[0, 1]`. sample_weight: Optional weighting of each example. Defaults to 1. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Returns: Update op. )rrrrr) r rrrrrrrrrr)r8rrrr;r;r<rHs  zRecall.update_statecCs0t|j|j|j}t|jdkr,|dS|S)Nrr)r)rrrrr)r8rNr;r;r<rNsz Recall.resultcs2tt|jtfdd|j|jfDdS)Ncsg|]}|tffqSr;)rr)rQr\)rr;r<r]sz&Recall.reset_state..)rr#rr rcrr)r8r;)rr<rdszRecall.reset_statecs<|j|j|jd}tt|}tt|t|S)N)rrr) rrrr4rr[rrr)r8rr)r:r;r<r[s  zRecall.get_config)NNNNN)N) rbryrzr{r5rHrNrdr[rr;r;)r:r<ras6 rcsHeZdZdZdfdd ZdddZdd Zfd d Zd d ZZ S)SensitivitySpecificityBasezAbstract base class for computing sensitivity and specificity. For additional information about specificity and sensitivity, see [the following](https://en.wikipedia.org/wiki/Sensitivity_and_specificity). Ncstt|j||ddkr$td||_||_|jdftjd|_ |jdftjd|_ |jdftjd|_ |jdftjd|_ d krd g|_ d |_n2fd d tdD}dg|dg|_ d|_dS)N)r2r3rz`num_thresholds` must be > 0.r)rfrhtrue_negativesrrrg?Fcs g|]}|dddqS)rg?r;)rQi)rr;r<r] sz7SensitivitySpecificityBase.__init__..gg?T)r4rr5rvaluerrpr(rrrrrrrr)r8rrrr2r3r)r:)rr<r5s8     z#SensitivitySpecificityBase.__init__c CsFtjtjj|jtjj|jtjj|jtjj |j i|||j |j |j |dS)aiAccumulates confusion matrix statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Defaults to 1. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Returns: Update op. )rrrr)r rrrrrrrrrrrrr)r8rrrr;r;r<rHs     z'SensitivitySpecificityBase.update_statecs:t|j|j|j|j|jf}tfdd|DdS)Ncsg|]}|tffqSr;)rr)rQr\)rr;r<r]/sz:SensitivitySpecificityBase.reset_state..)rrrrrrr rc)r8confusion_matrix_variablesr;)rr<rd*s   z&SensitivitySpecificityBase.reset_statecs4d|ji}tt|}tt|t|S)Nr)rr4rr[rrr)r8rr)r:r;r<r[2s z%SensitivitySpecificityBase.get_configcCsDt|||j}tt|d}tt||}t||dS)aReturns the maximum of dependent_statistic that satisfies the constraint. Args: constrained: Over these values the constraint is specified. A rank-1 tensor. dependent: From these values the maximum that satiesfies the constraint is selected. Values in this tensor and in `constrained` are linked by having the same threshold at each position, hence this tensor must have the same shape. predicate: A binary boolean functor to be applied to arguments `constrained` and `self.value`, e.g. `tf.greater`. Returns maximal dependent value, if no value satiesfies the constraint 0.0. rg)r%Zwhere_v2rr)ZgreaterrZ reduce_maxgather)r8Z constrainedZ dependent predicateZfeasibleZfeasible_existsZ max_dependentr;r;r<_find_max_under_constraint7sz5SensitivitySpecificityBase._find_max_under_constraint)rNNN)N) rbryrzr{r5rHrdr[rrr;r;)r:r<rs!  rz&keras.metrics.SensitivityAtSpecificitycs6eZdZdZd fdd ZddZfdd ZZS) SensitivityAtSpecificityamComputes best sensitivity where specificity is >= specified value. the sensitivity at a given specificity. `Sensitivity` measures the proportion of actual positives that are correctly identified as such (tp / (tp + fn)). `Specificity` measures the proportion of actual negatives that are correctly identified as such (tn / (tn + fp)). This metric creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the sensitivity at the given specificity. The threshold for the given specificity value is computed and used to evaluate the corresponding sensitivity. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `class_id` is specified, we calculate precision by considering only the entries in the batch for which `class_id` is above the threshold predictions, and computing the fraction of them for which `class_id` is indeed a correct label. For additional information about specificity and sensitivity, see [the following](https://en.wikipedia.org/wiki/Sensitivity_and_specificity). Args: specificity: A scalar value in range `[0, 1]`. num_thresholds: (Optional) Defaults to 200. The number of thresholds to use for matching the given specificity. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.SensitivityAtSpecificity(0.5) >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8], ... sample_weight=[1, 1, 2, 2, 1]) >>> m.result().numpy() 0.333333 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.SensitivityAtSpecificity()]) ``` rNcsB|dks|dkrtd||_||_tt|j|||||ddS)Nrrz*`specificity` must be in the range [0, 1].)rrr2r3)r specificityrr4rr5)r8rrrr2r3)r:r;r<r5s z!SensitivityAtSpecificity.__init__cCs<t|j|j|j}t|j|j|j}|||tjS)N)r)rrrrrr greater_equal)r8 specificities sensitivitiesr;r;r<rNs zSensitivityAtSpecificity.resultcs8|j|jd}tt|}tt|t|S)N)rr)rrr4rr[rrr)r8rr)r:r;r<r[s z#SensitivityAtSpecificity.get_config)rNNN)rbryrzr{r5rNr[rr;r;)r:r<rMs: rz&keras.metrics.SpecificityAtSensitivitycs6eZdZdZd fdd ZddZfdd ZZS) SpecificityAtSensitivityaDComputes best specificity where sensitivity is >= specified value. `Sensitivity` measures the proportion of actual positives that are correctly identified as such (tp / (tp + fn)). `Specificity` measures the proportion of actual negatives that are correctly identified as such (tn / (tn + fp)). This metric creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the specificity at the given sensitivity. The threshold for the given sensitivity value is computed and used to evaluate the corresponding specificity. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `class_id` is specified, we calculate precision by considering only the entries in the batch for which `class_id` is above the threshold predictions, and computing the fraction of them for which `class_id` is indeed a correct label. For additional information about specificity and sensitivity, see [the following](https://en.wikipedia.org/wiki/Sensitivity_and_specificity). Args: sensitivity: A scalar value in range `[0, 1]`. num_thresholds: (Optional) Defaults to 200. The number of thresholds to use for matching the given sensitivity. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.SpecificityAtSensitivity(0.5) >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8]) >>> m.result().numpy() 0.66666667 >>> m.reset_state() >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8], ... sample_weight=[1, 1, 2, 2, 2]) >>> m.result().numpy() 0.5 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.SpecificityAtSensitivity()]) ``` rNcsB|dks|dkrtd||_||_tt|j|||||ddS)Nrrz*`sensitivity` must be in the range [0, 1].)rrr2r3)r sensitivityrr4rr5)r8rrrr2r3)r:r;r<r5s z!SpecificityAtSensitivity.__init__cCs<t|j|j|j}t|j|j|j}|||tjS)N)r)rrrrrrr)r8rrr;r;r<rNs zSpecificityAtSensitivity.resultcs8|j|jd}tt|}tt|t|S)N)rr)rrr4rr[rrr)r8rr)r:r;r<r[s z#SpecificityAtSensitivity.get_config)rNNN)rbryrzr{r5rNr[rr;r;)r:r<rs8 rzkeras.metrics.PrecisionAtRecallcs6eZdZdZd fdd ZddZfdd ZZS) PrecisionAtRecallaComputes best precision where recall is >= specified value. This metric creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the precision at the given recall. The threshold for the given recall value is computed and used to evaluate the corresponding precision. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `class_id` is specified, we calculate precision by considering only the entries in the batch for which `class_id` is above the threshold predictions, and computing the fraction of them for which `class_id` is indeed a correct label. Args: recall: A scalar value in range `[0, 1]`. num_thresholds: (Optional) Defaults to 200. The number of thresholds to use for matching the given recall. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.PrecisionAtRecall(0.5) >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([0, 0, 0, 1, 1], [0, 0.3, 0.8, 0.3, 0.8], ... sample_weight=[2, 2, 2, 1, 1]) >>> m.result().numpy() 0.33333333 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.PrecisionAtRecall(recall=0.8)]) ``` rNcsB|dks|dkrtd||_||_tt|j|||||ddS)Nrrz%`recall` must be in the range [0, 1].)rrrr2r3)rrecallrr4rr5)r8rrrr2r3)r:r;r<r59s zPrecisionAtRecall.__init__cCs<t|j|j|j}t|j|j|j}|||tjS)N)r)rrrrrr)r8recalls precisionsr;r;r<rNJs zPrecisionAtRecall.resultcs8|j|jd}tt|}tt|t|S)N)rr)rrr4rr[rrr)r8rr)r:r;r<r[RszPrecisionAtRecall.get_config)rNNN)rbryrzr{r5rNr[rr;r;)r:r<rs0 rzkeras.metrics.RecallAtPrecisioncs6eZdZdZd fdd ZddZfdd ZZS) RecallAtPrecisionaComputes best recall where precision is >= specified value. For a given score-label-distribution the required precision might not be achievable, in this case 0.0 is returned as recall. This metric creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the recall at the given precision. The threshold for the given precision value is computed and used to evaluate the corresponding recall. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. If `class_id` is specified, we calculate precision by considering only the entries in the batch for which `class_id` is above the threshold predictions, and computing the fraction of them for which `class_id` is indeed a correct label. Args: precision: A scalar value in range `[0, 1]`. num_thresholds: (Optional) Defaults to 200. The number of thresholds to use for matching the given precision. class_id: (Optional) Integer class ID for which we want binary metrics. This must be in the half-open interval `[0, num_classes)`, where `num_classes` is the last dimension of predictions. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.RecallAtPrecision(0.8) >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9], ... sample_weight=[1, 0, 0, 1]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.RecallAtPrecision(precision=0.8)]) ``` rNcsB|dks|dkrtd||_||_tt|j|||||ddS)Nrrz(`precision` must be in the range [0, 1].)rrrr2r3)r precisionrr4rr5)r8rrrr2r3)r:r;r<r5s zRecallAtPrecision.__init__cCs<t|j|j|j}t|j|j|j}|||tjS)N)r)rrrrrr)r8rrr;r;r<rNs zRecallAtPrecision.resultcs8|j|jd}tt|}tt|t|S)N)rr)rrr4rr[rrr)r8rr)r:r;r<r[s zRecallAtPrecision.get_config)rNNN)rbryrzr{r5rNr[rr;r;)r:r<rXs3 rzkeras.metrics.AUCc sdeZdZdZdfdd Zed d Zd d Zdd dZddZ ddZ ddZ fddZ Z S)AUCaHApproximates the AUC (Area under the curve) of the ROC or PR curves. The AUC (Area under the curve) of the ROC (Receiver operating characteristic; default) or PR (Precision Recall) curves are quality measures of binary classifiers. Unlike the accuracy, and like cross-entropy losses, ROC-AUC and PR-AUC evaluate all the operational points of a model. This class approximates AUCs using a Riemann sum. During the metric accumulation phrase, predictions are accumulated within predefined buckets by value. The AUC is then computed by interpolating per-bucket averages. These buckets define the evaluated operational points. This metric creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the AUC. To discretize the AUC curve, a linearly spaced set of thresholds is used to compute pairs of recall and precision values. The area under the ROC-curve is therefore computed using the height of the recall values by the false positive rate, while the area under the PR-curve is the computed using the height of the precision values by the recall. This value is ultimately returned as `auc`, an idempotent operation that computes the area under a discretized curve of precision versus recall values (computed using the aforementioned variables). The `num_thresholds` variable controls the degree of discretization with larger numbers of thresholds more closely approximating the true AUC. The quality of the approximation may vary dramatically depending on `num_thresholds`. The `thresholds` parameter can be used to manually specify thresholds which split the predictions more evenly. For a best approximation of the real AUC, `predictions` should be distributed approximately uniformly in the range [0, 1] (if `from_logits=False`). The quality of the AUC approximation may be poor if this is not the case. Setting `summation_method` to 'minoring' or 'majoring' can help quantify the error in the approximation by providing lower or upper bound estimate of the AUC. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: num_thresholds: (Optional) Defaults to 200. The number of thresholds to use when discretizing the roc curve. Values must be > 1. curve: (Optional) Specifies the name of the curve to be computed, 'ROC' [default] or 'PR' for the Precision-Recall-curve. summation_method: (Optional) Specifies the [Riemann summation method]( https://en.wikipedia.org/wiki/Riemann_sum) used. 'interpolation' (default) applies mid-point summation scheme for `ROC`. For PR-AUC, interpolates (true/false) positives but not the ratio that is precision (see Davis & Goadrich 2006 for details); 'minoring' applies left summation for increasing intervals and right summation for decreasing intervals; 'majoring' does the opposite. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. thresholds: (Optional) A list of floating point values to use as the thresholds for discretizing the curve. If set, the `num_thresholds` parameter is ignored. Values should be in [0, 1]. Endpoint thresholds equal to {-epsilon, 1+epsilon} for a small positive epsilon value will be automatically included with these to correctly handle predictions equal to exactly 0 or 1. multi_label: boolean indicating whether multilabel data should be treated as such, wherein AUC is computed separately for each label and then averaged across labels, or (when False) if the data should be flattened into a single label before AUC computation. In the latter case, when multilabel data is passed to AUC, each label-prediction pair is treated as an individual data point. Should be set to False for multi-class data. num_labels: (Optional) The number of labels, used when `multi_label` is True. If `num_labels` is not specified, then state variables get created on the first call to `update_state`. label_weights: (Optional) list, array, or tensor of non-negative weights used to compute AUCs for multilabel data. When `multi_label` is True, the weights are applied to the individual label AUCs when they are averaged to produce the multi-label AUC. When it's False, they are used to weight the individual label predictions in computing the confusion matrix on the flattened data. Note that this is unlike class_weights in that class_weights weights the example depending on the value of its label, whereas label_weights depends only on the index of that label before flattening; therefore `label_weights` should not be used for multi-class data. from_logits: boolean indicating whether the predictions (`y_pred` in `update_state`) are probabilities or sigmoid logits. As a rule of thumb, when using a keras loss, the `from_logits` constructor argument of the loss should match the AUC `from_logits` constructor argument. Standalone usage: >>> m = tf.keras.metrics.AUC(num_thresholds=3) >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9]) >>> # threshold values are [0 - 1e-7, 0.5, 1 + 1e-7] >>> # tp = [2, 1, 0], fp = [2, 0, 0], fn = [0, 1, 2], tn = [0, 2, 2] >>> # tp_rate = recall = [1, 0.5, 0], fp_rate = [1, 0, 0] >>> # auc = ((((1+0.5)/2)*(1-0)) + (((0.5+0)/2)*(0-0))) = 0.75 >>> m.result().numpy() 0.75 >>> m.reset_state() >>> m.update_state([0, 0, 1, 1], [0, 0.5, 0.3, 0.9], ... sample_weight=[1, 0, 0, 1]) >>> m.result().numpy() 1.0 Usage with `compile()` API: ```python # Reports the AUC of a model outputing a probability. model.compile(optimizer='sgd', loss=tf.keras.losses.BinaryCrossentropy(), metrics=[tf.keras.metrics.AUC()]) # Reports the AUC of a model outputing a logit. model.compile(optimizer='sgd', loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), metrics=[tf.keras.metrics.AUC(from_logits=True)]) ``` rROC interpolationNFc st|tjr0|ttjkr0td|ttjt|tjr`|ttjkr`td|ttj|dk rt|d|_t |}t t dg|dg|_ n6dkrtd|_fdd tdD}d |_ t dtg|dtg|_t|tjr||_ntj||_t|tjr6||_ntj||_tt|j||d ||_| dk rtj| |jd } tj| d dg} t|  | |_ WdQRXnd|_ | |_!d|_"|jr|rt#$d|g} |%| n|rtd|%ddS)Nz,Invalid curve: "{}". Valid options are: "{}"z7Invalid summation method: "{}". Valid options are: "{}"rgg?rz`num_thresholds` must be > 1.cs g|]}|dddqS)rg?r;)rQr)rr;r<r]Isz AUC.__init__..T)r2r3)r3z3All values of `label_weights` must be non-negative.)messageFz7`num_labels` is needed only when `multi_label` is True.)&rIr AUCCurverrformatAUCSummationMethodrrsortedrrarrayrrr epsilon _thresholdscurveZfrom_strsummation_methodr4r r5 multi_labelrZconstantr3r&Zassert_non_negativer rW label_weights _from_logits_builtr TensorShape_build) r8rrrr2r3rrZ num_labelsr from_logitsZchecksrf)r:)rr<r5"sf         z AUC.__init__cCs t|jS)z'The thresholds used for evaluating AUC.)rr)r8r;r;r<ryszAUC.thresholdsc Cs|jrB|jdkrtd|j|d|_tt|j|jg}ntt|jg}||_|j d|t j d|_ |j d|t j d|_ |j d|t j d|_|j d|t j d|_|jrttsttWd QRXd |_d S) zCInitialize TP, FP, TN, and FN tensors, given the shape of the data.rzD`y_true` must have rank=2 when `multi_label` is True. Found rank %s.rr)rfrhrrrNT)rndimsr _num_labelsr rZ Dimensionr_build_input_shaperpr(rrrrrr rorexecuting_eagerlyr _initialize_variables _get_sessionr)r8rfZvariable_shaper;r;r<r~s>        z AUC._buildc Csg}|js|t|j|js,|jdk r|dfg}|jrf||jdf|j df|j df|j dfg|jdk r| |jdft j|ddg}|jrdn|j}|jrt|}t|Jtjtjj|jtjj|j tjj|j tjj|j i|||j|j||j|dSQRXdS)aiAccumulates confusion matrix statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Defaults to 1. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Returns: Update op. N)NL)Tr$)r$z#Number of labels is not consistent.)r )rrrr)rrr rrfrrextendrrrrrVr&Z assert_shapesrr Zsigmoidr rWr rrrrrrrr)r8rrrdepsZshapesrr;r;r<rHsD       zAUC.update_statec Cs|jd|jd|jdd}|j|j}|d|jd|dd}tj|t|ddd}|jddt||dd}tt |d|jddk|dddktj|d|jdt|dddddt |dd}tj|||t |t|jdd|j ddddd}|j rtj||jddd }|jdkrntj||jdStjtt||jt|j|jdSntj|d dSdS) aInterpolation formula inspired by section 4 of Davis & Goadrich 2006. https://www.biostat.wisc.edu/~page/rocpr.pdf Note here we derive & use a closed formula not present in the paper as follows: Precision = TP / (TP + FP) = TP / P Modeling all of TP (true positive), FP (false positive) and their sum P = TP + FP (predicted positive) as varying linearly within each interval [A, B] between successive thresholds, we get Precision slope = dTP / dP = (TP_B - TP_A) / (P_B - P_A) = (TP - TP_A) / (P - P_A) Precision = (TP_A + slope * (P - P_A)) / P The area within the interval is (slope / total_pos_weight) times int_A^B{Precision.dP} = int_A^B{(TP_A + slope * (P - P_A)) * dP / P} int_A^B{Precision.dP} = int_A^B{slope * dP + intercept * dP / P} where intercept = TP_A - slope * P_A = TP_B - slope * P_B, resulting in int_A^B{Precision.dP} = TP_B - TP_A + intercept * log(P_B / P_A) Bringing back the factor (slope / total_pos_weight) we'd put aside, we get slope * [dTP + intercept * log(P_B / P_A)] / total_pos_weight where dTP == TP_B - TP_A. Note that when P_A == 0 the above calculation simplifies into int_A^B{Precision.dTP} = int_A^B{slope * dTP} = slope * (TP_B - TP_A) which is really equivalent to imputing constant precision throughout the first bucket having >0 true positives. Returns: pr_auc: an approximation of the area under the P-R curve. Nrr prec_slope)r2Zrecall_relative_ratiopr_auc_increment _by_label)r2rinterpolate_pr_auc)rrrr)rmaximumrr%where logical_and ones_likelogrrrr2rr) r8ZdtppZdpr(Z interceptZ safe_p_ratior) by_label_aucr;r;r<r+s:,  "("   zAUC.interpolate_pr_aucc Cs|jtjjkr$|jtjjkr$|St |j |j |j }|jtjj krht |j |j |j}|}|}nt |j |j |j }|}|}|jtjjkr|d|jd|ddd}nT|jtjjkrt|d|jd|dd}n"t|d|jd|dd}|jrt|d|jd|dd|}tj||jddd}|jdkrltj||jdStj tt||jt|j|jdSn2tjt|d|jd|dd||jdSdS)Nrg@r*r)r2r)r2)rr r ZPRrrZ INTERPOLATIONr+r)rrrr rrrZMINORINGminimumr,rrrr2rr) r8rZfp_ratexyrZheightsZ riemann_termsr2r;r;r<rN: sD$$"    $z AUC.resultcsVjrRjjjjf}jr:tfdd|Dntfdd|DdS)Ncs"g|]}|tjjffqSr;)rrrr)rQr\)r8r;r<r]t sz#AUC.reset_state..csg|]}|tjffqSr;)rrr)rQr\)r8r;r<r]w s)rrrrrrr rc)r8rr;)r8r<rdn s   zAUC.reset_statecspt|jrt|j}n|j}|j|jj|jj|jdd|j |d}t t | }t t|t|S)Nr)rrrrrr)r$rr rrrrrrrr4r r[rrr)r8rrr)r:r;r<r[z s  zAUC.get_config) rr r NNNFNNF)N)rbryrzr{r5r|rrrHr+rNrdr[rr;r;)r:r<r s$sM * AQ4 r zkeras.metrics.CosineSimilaritycs"eZdZdZdfdd ZZS)CosineSimilarityaDComputes the cosine similarity between the labels and predictions. `cosine similarity = (a . b) / ||a|| ||b||` See: [Cosine Similarity](https://en.wikipedia.org/wiki/Cosine_similarity). This metric keeps the average cosine similarity between `predictions` and `labels` over a stream of data. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. axis: (Optional) Defaults to -1. The dimension along which the cosine similarity is computed. Standalone usage: >>> # l2_norm(y_true) = [[0., 1.], [1./1.414, 1./1.414]] >>> # l2_norm(y_pred) = [[1., 0.], [1./1.414, 1./1.414]] >>> # l2_norm(y_true) . l2_norm(y_pred) = [[0., 0.], [0.5, 0.5]] >>> # result = mean(sum(l2_norm(y_true) . l2_norm(y_pred), axis=1)) >>> # = ((0. + 0.) + (0.5 + 0.5)) / 2 >>> m = tf.keras.metrics.CosineSimilarity(axis=1) >>> m.update_state([[0., 1.], [1., 1.]], [[1., 0.], [1., 1.]]) >>> m.result().numpy() 0.49999997 >>> m.reset_state() >>> m.update_state([[0., 1.], [1., 1.]], [[1., 0.], [1., 1.]], ... sample_weight=[0.3, 0.7]) >>> m.result().numpy() 0.6999999 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.CosineSimilarity(axis=1)]) ``` cosine_similarityNr6cstt|jt|||ddS)N)r3r)r4r7r5r8)r8r2r3r)r:r;r<r5 s zCosineSimilarity.__init__)r8Nr6)rbryrzr{r5rr;r;)r:r<r7 s+r7zkeras.metrics.MeanAbsoluteErrorcs"eZdZdZdfdd ZZS)MeanAbsoluteErroraComputes the mean absolute error between the labels and predictions. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.MeanAbsoluteError() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]]) >>> m.result().numpy() 0.25 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]], ... sample_weight=[1, 0]) >>> m.result().numpy() 0.5 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.MeanAbsoluteError()]) ``` rNcstt|jt||ddS)N)r3)r4r9r5r)r8r2r3)r:r;r<r5 s zMeanAbsoluteError.__init__)rN)rbryrzr{r5rr;r;)r:r<r9 sr9z)keras.metrics.MeanAbsolutePercentageErrorcs"eZdZdZdfdd ZZS)MeanAbsolutePercentageErroraComputes the mean absolute percentage error between `y_true` and `y_pred`. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.MeanAbsolutePercentageError() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]]) >>> m.result().numpy() 250000000.0 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]], ... sample_weight=[1, 0]) >>> m.result().numpy() 500000000.0 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.MeanAbsolutePercentageError()]) ``` rNcstt|jt||ddS)N)r3)r4r:r5r)r8r2r3)r:r;r<r5 s z$MeanAbsolutePercentageError.__init__)rN)rbryrzr{r5rr;r;)r:r<r: sr:zkeras.metrics.MeanSquaredErrorcs"eZdZdZdfdd ZZS)MeanSquaredErroraComputes the mean squared error between `y_true` and `y_pred`. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.MeanSquaredError() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]]) >>> m.result().numpy() 0.25 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]], ... sample_weight=[1, 0]) >>> m.result().numpy() 0.5 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.MeanSquaredError()]) ``` rNcstt|jt||ddS)N)r3)r4r;r5r)r8r2r3)r:r;r<r5' s zMeanSquaredError.__init__)rN)rbryrzr{r5rr;r;)r:r<r; sr;z)keras.metrics.MeanSquaredLogarithmicErrorcs"eZdZdZdfdd ZZS)MeanSquaredLogarithmicErroraComputes the mean squared logarithmic error between `y_true` and `y_pred`. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.MeanSquaredLogarithmicError() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]]) >>> m.result().numpy() 0.12011322 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]], ... sample_weight=[1, 0]) >>> m.result().numpy() 0.24022643 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.MeanSquaredLogarithmicError()]) ``` rNcstt|jt||ddS)N)r3)r4r<r5r)r8r2r3)r:r;r<r5K s z$MeanSquaredLogarithmicError.__init__)rN)rbryrzr{r5rr;r;)r:r<r<, sr<zkeras.metrics.Hingecs"eZdZdZdfdd ZZS)HingeaComputes the hinge metric between `y_true` and `y_pred`. `y_true` values are expected to be -1 or 1. If binary (0 or 1) labels are provided we will convert them to -1 or 1. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.Hinge() >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]]) >>> m.result().numpy() 1.3 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]], ... sample_weight=[1, 0]) >>> m.result().numpy() 1.1 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.Hinge()]) ``` rNcstt|jt||ddS)N)r3)r4r=r5r)r8r2r3)r:r;r<r5o szHinge.__init__)rN)rbryrzr{r5rr;r;)r:r<r=P sr=zkeras.metrics.SquaredHingecs"eZdZdZdfdd ZZS) SquaredHingeaComputes the squared hinge metric between `y_true` and `y_pred`. `y_true` values are expected to be -1 or 1. If binary (0 or 1) labels are provided we will convert them to -1 or 1. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.SquaredHinge() >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]]) >>> m.result().numpy() 1.86 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]], ... sample_weight=[1, 0]) >>> m.result().numpy() 1.46 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.SquaredHinge()]) ``` rNcstt|jt||ddS)N)r3)r4r>r5r)r8r2r3)r:r;r<r5 szSquaredHinge.__init__)rN)rbryrzr{r5rr;r;)r:r<r>s s r>zkeras.metrics.CategoricalHingecs"eZdZdZdfdd ZZS)CategoricalHingeaComputes the categorical hinge metric between `y_true` and `y_pred`. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.CategoricalHinge() >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]]) >>> m.result().numpy() 1.4000001 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]], ... sample_weight=[1, 0]) >>> m.result().numpy() 1.2 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.CategoricalHinge()]) ``` rNcstt|jt||ddS)N)r3)r4r?r5r)r8r2r3)r:r;r<r5 szCategoricalHinge.__init__)rN)rbryrzr{r5rr;r;)r:r<r? sr?z"keras.metrics.RootMeanSquaredErrorcs8eZdZdZd fdd Zd fdd Zdd ZZS) RootMeanSquaredErrora/Computes root mean squared error metric between `y_true` and `y_pred`. Standalone usage: >>> m = tf.keras.metrics.RootMeanSquaredError() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]]) >>> m.result().numpy() 0.5 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]], ... sample_weight=[1, 0]) >>> m.result().numpy() 0.70710677 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.RootMeanSquaredError()]) ``` root_mean_squared_errorNcstt|j||ddS)N)r3)r4r@r5)r8r2r3)r:r;r<r5 szRootMeanSquaredError.__init__csLt||j}t||j}t||\}}t||}tt|j||dS)apAccumulates root mean squared error statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Defaults to 1. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Returns: Update op. )r) r)rr7rrZsquared_differencer4r@rH)r8rrrZerror_sq)r:r;r<rH s    z!RootMeanSquaredError.update_statecCstt|j|jS)N)r)sqrtrrr)r8r;r;r<rN szRootMeanSquaredError.result)rAN)N)rbryrzr{r5rHrNrr;r;)r:r<r@ sr@zkeras.metrics.LogCoshErrorcs"eZdZdZdfdd ZZS) LogCoshErroraComputes the logarithm of the hyperbolic cosine of the prediction error. `logcosh = log((exp(x) + exp(-x))/2)`, where x is the error (y_pred - y_true) Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.LogCoshError() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]]) >>> m.result().numpy() 0.10844523 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]], ... sample_weight=[1, 0]) >>> m.result().numpy() 0.21689045 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.LogCoshError()]) ``` rNcstt|jt||ddS)N)r3)r4rCr5r)r8r2r3)r:r;r<r5 szLogCoshError.__init__)rN)rbryrzr{r5rr;r;)r:r<rC srCzkeras.metrics.Poissoncs"eZdZdZdfdd ZZS)PoissonaComputes the Poisson metric between `y_true` and `y_pred`. `metric = y_pred - y_true * log(y_pred)` Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.Poisson() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]]) >>> m.result().numpy() 0.49999997 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[1, 1], [0, 0]], ... sample_weight=[1, 0]) >>> m.result().numpy() 0.99999994 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.Poisson()]) ``` rNcstt|jt||ddS)N)r3)r4rDr5r)r8r2r3)r:r;r<r57 szPoisson.__init__)rN)rbryrzr{r5rr;r;)r:r<rD srDzkeras.metrics.KLDivergencecs"eZdZdZdfdd ZZS) KLDivergenceaComputes Kullback-Leibler divergence metric between `y_true` and `y_pred`. `metric = y_true * log(y_true / y_pred)` Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.KLDivergence() >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]]) >>> m.result().numpy() 0.45814306 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]], ... sample_weight=[1, 0]) >>> m.result().numpy() 0.9162892 Usage with `compile()` API: ```python model.compile(optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.KLDivergence()]) ``` rNcstt|jt||ddS)N)r3)r4rEr5r)r8r2r3)r:r;r<r5[ s zKLDivergence.__init__)rN)rbryrzr{r5rr;r;)r:r<rE; srEzkeras.metrics.MeanIoUcsHeZdZdZd fdd ZdddZddZd d Zfd d ZZ S)MeanIoUacComputes the mean Intersection-Over-Union metric. Mean Intersection-Over-Union is a common evaluation metric for semantic image segmentation, which first computes the IOU for each semantic class and then computes the average over classes. IOU is defined as follows: IOU = true_positive / (true_positive + false_positive + false_negative). The predictions are accumulated in a confusion matrix, weighted by `sample_weight` and the metric is then calculated from it. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. Args: num_classes: The possible number of labels the prediction task can have. This value must be provided, since a confusion matrix of dimension = [num_classes, num_classes] will be allocated. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> # cm = [[1, 1], >>> # [1, 1]] >>> # sum_row = [2, 2], sum_col = [2, 2], true_positives = [1, 1] >>> # iou = true_positives / (sum_row + sum_col - true_positives)) >>> # result = (1 / (2 + 2 - 1) + 1 / (2 + 2 - 1)) / 2 = 0.33 >>> m = tf.keras.metrics.MeanIoU(num_classes=2) >>> m.update_state([0, 0, 1, 1], [0, 1, 0, 1]) >>> m.result().numpy() 0.33333334 >>> m.reset_state() >>> m.update_state([0, 0, 1, 1], [0, 1, 0, 1], ... sample_weight=[0.3, 0.3, 0.3, 0.1]) >>> m.result().numpy() 0.23809525 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.MeanIoU(num_classes=2)]) ``` Ncs6tt|j||d||_|jd||ftjd|_dS)N)r2r3Ztotal_confusion_matrix)rfrh)r4rFr5 num_classesrpr(rtotal_cm)r8rGr2r3)r:r;r<r5 s zMeanIoU.__init__cCst||j}t||j}|jjdkr6t|dg}|jjdkrPt|dg}|dk rt||j}|jjdkrt|dg}tj|||j||jd}|j |S)amAccumulates the confusion matrix statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Defaults to 1. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Returns: Update op. rr6N)rwr3) r)rr7rfrr%reshaper'rGrHr)r8rrrZ current_cmr;r;r<rH s"    zMeanIoU.update_statecCstjtj|jdd|jd}tjtj|jdd|jd}tjt|j|jd}|||}ttjt|d|jd}t||}ttj|dd|S)zBCompute the mean intersection-over-union via the confusion matrix.r)r)r3rZmean_iou)r2) r)rrrHr7r%Ztensor_diag_part not_equalr)r8Z sum_over_rowZ sum_over_colr denominatorZnum_valid_entriesZiour;r;r<rN s  zMeanIoU.resultcCs t|jt|j|jfdS)N)r set_valuerHrrrG)r8r;r;r<rd szMeanIoU.reset_statecs4d|ji}tt|}tt|t|S)NrG)rGr4rFr[rrr)r8rr)r:r;r<r[ s zMeanIoU.get_config)NN)N) rbryrzr{r5rHrNrdr[rr;r;)r:r<rF` s / &rFzkeras.metrics.MeanTensorcs\eZdZdZdfdd ZddZedd Zed d Zdd d Z ddZ ddZ Z S) MeanTensoraComputes the element-wise (weighted) mean of the given tensors. `MeanTensor` returns a tensor with the same shape of the input tensors. The mean value is updated by keeping local variables `total` and `count`. The `total` tracks the sum of the weighted values, and `count` stores the sum of the weighted counts. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. shape: (Optional) A list of integers, a tuple of integers, or a 1-D Tensor of type int32. If not specified, the shape is inferred from the values at the first call of update_state. Standalone usage: >>> m = tf.keras.metrics.MeanTensor() >>> m.update_state([0, 1, 2, 3]) >>> m.update_state([4, 5, 6, 7]) >>> m.result().numpy() array([2., 3., 4., 5.], dtype=float32) >>> m.update_state([12, 10, 8, 6], sample_weight= [0, 0.2, 0.5, 1]) >>> m.result().numpy() array([2. , 3.6363635, 4.8 , 5.3333335], dtype=float32) >>> m = tf.keras.metrics.MeanTensor(dtype=tf.float64, shape=(1, 4)) >>> m.result().numpy() array([[0., 0., 0., 0.]]) >>> m.update_state([[0, 1, 2, 3]]) >>> m.update_state([[4, 5, 6, 7]]) >>> m.result().numpy() array([[2., 3., 4., 5.]]) mean_tensorNcsBtt|j||dd|_d|_d|_d|_|dk r>||dS)N)r2r3F)r4rMr5_shape_total_countrr)r8r2r3rf)r:r;r<r5 szMeanTensor.__init__c Cspt||_|j|_|jd|tjd|_|jd|tjd|_t t s\t t WdQRXd|_dS)Nr)rfrhrT)r rrOrrpr(rrPrQr rorr r r!r"r)r8rfr;r;r<r s  zMeanTensor._buildcCs|jr |jSdS)N)rrP)r8r;r;r<r szMeanTensor.totalcCs|jr |jSdS)N)rrQ)r8r;r;r<r" szMeanTensor.countc Cst||j}|js"||jn |j|jkrBtd|j|jt |}|dk rt||j}t j ||d\}}}yt ||}Wn@tk rt|}t|}tj|tt||d}YnXt||}t||}|j|}t|g|j|SQRXdS)zAccumulates statistics for computing the element-wise mean. Args: values: Per-example value. sample_weight: Optional weighting of each example. Defaults to 1. Returns: Update op. zpMeanTensor input values must always have the same shape. Expected shape (set during the first call): {}. Got: {}N)r)r)r)rr7rrrfrOrrr%r/rrr,rr rrrrrrPrr rWrQ)r8rrrrrrrr;r;r<rH& s0         zMeanTensor.update_statecCs|jstdt|j|jS)NzMeanTensor does not have any result yet. Please call the MeanTensor instance or use `.update_state(value)` before retrieving the result.)rrr)rrr)r8r;r;r<rNQ szMeanTensor.resultcs$jr tfddjDdS)Ncs g|]}|tjfqSr;)rrrOas_list)rQr\)r8r;r<r]\ sz*MeanTensor.reset_state..)rr rcr+)r8r;)r8r<rdY szMeanTensor.reset_state)rNNN)N) rbryrzr{r5rr|rrrHrNrdrr;r;)r:r<rM s#    +rMz keras.metrics.BinaryCrossentropycs"eZdZdZdfdd ZZS) BinaryCrossentropyaComputes the crossentropy metric between the labels and predictions. This is the crossentropy metric class to be used when there are only two label classes (0 and 1). Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. from_logits: (Optional )Whether output is expected to be a logits tensor. By default, we consider that output encodes a probability distribution. label_smoothing: (Optional) Float in [0, 1]. When > 0, label values are smoothed, meaning the confidence on label values are relaxed. e.g. `label_smoothing=0.2` means that we will use a value of `0.1` for label `0` and `0.9` for label `1`". Standalone usage: >>> m = tf.keras.metrics.BinaryCrossentropy() >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]]) >>> m.result().numpy() 0.81492424 >>> m.reset_state() >>> m.update_state([[0, 1], [0, 0]], [[0.6, 0.4], [0.4, 0.6]], ... sample_weight=[1, 0]) >>> m.result().numpy() 0.9162905 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.BinaryCrossentropy()]) ``` rNFrcstt|jt||||ddS)N)r3rlabel_smoothing)r4rSr5r)r8r2r3rrT)r:r;r<r5 s  zBinaryCrossentropy.__init__)rNFr)rbryrzr{r5rr;r;)r:r<rS_ s &rSz%keras.metrics.CategoricalCrossentropycs"eZdZdZdfdd ZZS) CategoricalCrossentropyaComputes the crossentropy metric between the labels and predictions. This is the crossentropy metric class to be used when there are multiple label classes (2 or more). Here we assume that labels are given as a `one_hot` representation. eg., When labels values are [2, 0, 1], `y_true` = [[0, 0, 1], [1, 0, 0], [0, 1, 0]]. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. from_logits: (Optional) Whether output is expected to be a logits tensor. By default, we consider that output encodes a probability distribution. label_smoothing: (Optional) Float in [0, 1]. When > 0, label values are smoothed, meaning the confidence on label values are relaxed. e.g. `label_smoothing=0.2` means that we will use a value of `0.1` for label `0` and `0.9` for label `1`" Standalone usage: >>> # EPSILON = 1e-7, y = y_true, y` = y_pred >>> # y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON) >>> # y` = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]] >>> # xent = -sum(y * log(y'), axis = -1) >>> # = -((log 0.95), (log 0.1)) >>> # = [0.051, 2.302] >>> # Reduced xent = (0.051 + 2.302) / 2 >>> m = tf.keras.metrics.CategoricalCrossentropy() >>> m.update_state([[0, 1, 0], [0, 0, 1]], ... [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]) >>> m.result().numpy() 1.1769392 >>> m.reset_state() >>> m.update_state([[0, 1, 0], [0, 0, 1]], ... [[0.05, 0.95, 0], [0.1, 0.8, 0.1]], ... sample_weight=tf.constant([0.3, 0.7])) >>> m.result().numpy() 1.6271976 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.CategoricalCrossentropy()]) ``` rNFrcstt|jt||||ddS)N)r3rrT)r4rUr5r)r8r2r3rrT)r:r;r<r5 s  z CategoricalCrossentropy.__init__)rNFr)rbryrzr{r5rr;r;)r:r<rU s 1rUz+keras.metrics.SparseCategoricalCrossentropycs"eZdZdZdfdd ZZS) SparseCategoricalCrossentropya^Computes the crossentropy metric between the labels and predictions. Use this crossentropy metric when there are two or more label classes. We expect labels to be provided as integers. If you want to provide labels using `one-hot` representation, please use `CategoricalCrossentropy` metric. There should be `# classes` floating point values per feature for `y_pred` and a single floating point value per feature for `y_true`. In the snippet below, there is a single floating point value per example for `y_true` and `# classes` floating pointing values per example for `y_pred`. The shape of `y_true` is `[batch_size]` and the shape of `y_pred` is `[batch_size, num_classes]`. Args: name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. from_logits: (Optional) Whether output is expected to be a logits tensor. By default, we consider that output encodes a probability distribution. axis: (Optional) Defaults to -1. The dimension along which the metric is computed. Standalone usage: >>> # y_true = one_hot(y_true) = [[0, 1, 0], [0, 0, 1]] >>> # logits = log(y_pred) >>> # softmax = exp(logits) / sum(exp(logits), axis=-1) >>> # softmax = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]] >>> # xent = -sum(y * log(softmax), 1) >>> # log(softmax) = [[-2.9957, -0.0513, -16.1181], >>> # [-2.3026, -0.2231, -2.3026]] >>> # y_true * log(softmax) = [[0, -0.0513, 0], [0, 0, -2.3026]] >>> # xent = [0.0513, 2.3026] >>> # Reduced xent = (0.0513 + 2.3026) / 2 >>> m = tf.keras.metrics.SparseCategoricalCrossentropy() >>> m.update_state([1, 2], ... [[0.05, 0.95, 0], [0.1, 0.8, 0.1]]) >>> m.result().numpy() 1.1769392 >>> m.reset_state() >>> m.update_state([1, 2], ... [[0.05, 0.95, 0], [0.1, 0.8, 0.1]], ... sample_weight=tf.constant([0.3, 0.7])) >>> m.result().numpy() 1.6271976 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.SparseCategoricalCrossentropy()]) ``` rNFr6cstt|jt||||ddS)N)r3rr)r4rVr5r)r8r2r3rr)r:r;r<r5 s  z&SparseCategoricalCrossentropy.__init__)rNFr6)rbryrzr{r5rr;r;)r:r<rV s 8rVcs"eZdZdZdfdd ZZS)SumOverBatchSizea+Computes the weighted sum over batch size of the given values. For example, if values is [1, 3, 5, 7] then the metric value is 4. If the weights were specified as [1, 1, 0, 0] then the value would be 1. This metric creates two variables, `total` and `count` that are used to compute the average of `values`. This average is ultimately returned as sum over batch size which is an idempotent operation that simply divides `total` by `count`. If `sample_weight` is `None`, weights default to 1. Use `sample_weight` of 0 to mask values. sum_over_batch_sizeNcstt|jtjj||ddS)N)rr2r3)r4rWr5r rr)r8r2r3)r:r;r<r5* s zSumOverBatchSize.__init__)rXN)rbryrzr{r5rr;r;)r:r<rW s rWcs<eZdZdZd fdd Zd fdd ZfddZZS) SumOverBatchSizeMetricWrapperzAWraps a function with the `SumOverBatchSizeMetricWrapper` metric.Nc s$tt|j||d||_||_dS)aVCreates a `SumOverBatchSizeMetricWrapper` instance. Args: fn: The metric function to wrap, with signature `fn(y_true, y_pred, **kwargs)`. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. **kwargs: The keyword arguments that are passed on to `fn`. )r2r3N)r4rYr5rr)r8rr2r3r9)r:r;r<r54 s z&SumOverBatchSizeMetricWrapper.__init__csbt||j}t||j}t||\}}t|jt }|||f|j }t t |j ||dS)N)r)r)rr7rrr>r?rrr=rr4rYrH)r8rrrrr)r:r;r<rHB s  z*SumOverBatchSizeMetricWrapper.update_statecs`i}x0|jD]"\}}t|r*t|n|||<qWtt|}tt |t |S)N) rrr$r rr4rYr[rr)r8rrr\r)r:r;r<r[M s z(SumOverBatchSizeMetricWrapper.get_config)NN)N)rbryrzr{r5rHr[rr;r;)r:r<rY1 s rYcCsVt||g\\}}}|j|j|j|jkr>t||j}tt||t S)N) r rrfrr3r)requalr r6)rrrr;r;r<rU s  rzkeras.metrics.binary_accuracy?cCs@t|}t||j}t||k|j}tjt||ddS)axCalculates how often predictions match binary labels. Standalone usage: >>> y_true = [[1], [1], [0], [0]] >>> y_pred = [[1], [1], [0], [0]] >>> m = tf.keras.metrics.binary_accuracy(y_true, y_pred) >>> assert m.shape == (4,) >>> m.numpy() array([1., 1., 1., 1.], dtype=float32) Args: y_true: Ground truth values. shape = `[batch_size, d0, .. dN]`. y_pred: The predicted values. shape = `[batch_size, d0, .. dN]`. threshold: (Optional) Float representing the threshold for deciding whether prediction values are 1 or 0. Returns: Binary accuracy values. shape = `[batch_size, d0, .. dN-1]` r6)r)r rr)rr3r rrZ)rrrr;r;r<r_ s rz"keras.metrics.categorical_accuracyc Cs,tttj|ddtj|ddtS)aCalculates how often predictions match one-hot labels. Standalone usage: >>> y_true = [[0, 0, 1], [0, 1, 0]] >>> y_pred = [[0.1, 0.9, 0.8], [0.05, 0.95, 0]] >>> m = tf.keras.metrics.categorical_accuracy(y_true, y_pred) >>> assert m.shape == (2,) >>> m.numpy() array([0., 1.], dtype=float32) You can provide logits of classes as `y_pred`, since argmax of logits and probabilities are same. Args: y_true: One-hot ground truth values. y_pred: The prediction values. Returns: Categorical accuracy values. r6)r)r)rrZargmaxr r6)rrr;r;r<r{ srz)keras.metrics.sparse_categorical_accuracycCst|}t|}|jj}|jj}|dk r^|dk r^tt|tt|kr^t|dg}t j |dd}t |t |krt |t |}t t ||tS)aCalculates how often predictions match integer labels. Standalone usage: >>> y_true = [2, 1] >>> y_pred = [[0.1, 0.9, 0.8], [0.05, 0.95, 0]] >>> m = tf.keras.metrics.sparse_categorical_accuracy(y_true, y_pred) >>> assert m.shape == (2,) >>> m.numpy() array([0., 1.], dtype=float32) You can provide logits of classes as `y_pred`, since argmax of logits and probabilities are same. Args: y_true: Integer ground truth values. y_pred: The prediction values. Returns: Sparse categorical accuracy values. Nr6)r)r rrfrrr Z int_shaper%Zsqueezer)r\r3rrZr6)rr y_pred_rank y_true_rankr;r;r<r s  rz(keras.metrics.top_k_categorical_accuracyrc Cs$tt|tj|dd|tS)a'Computes how often targets are in the top `K` predictions. Standalone usage: >>> y_true = [[0, 0, 1], [0, 1, 0]] >>> y_pred = [[0.1, 0.9, 0.8], [0.05, 0.95, 0]] >>> m = tf.keras.metrics.top_k_categorical_accuracy(y_true, y_pred, k=3) >>> assert m.shape == (2,) >>> m.numpy() array([1., 1.], dtype=float32) Args: y_true: The ground truth values. y_pred: The prediction values. k: (Optional) Number of top elements to look at for computing accuracy. Defaults to 5. Returns: Top K categorical accuracy value. r6)r)r)rr*in_top_kr\r r6)rrrr;r;r<r srz/keras.metrics.sparse_top_k_categorical_accuracyc Cst|jj}t|jj}|dk r`|dk r`|dkrJt|d|jdg}|dkr`t|dg}tt |t|d|t S)a=Computes how often integer targets are in the top `K` predictions. Standalone usage: >>> y_true = [2, 1] >>> y_pred = [[0.1, 0.9, 0.8], [0.05, 0.95, 0]] >>> m = tf.keras.metrics.sparse_top_k_categorical_accuracy( ... y_true, y_pred, k=3) >>> assert m.shape == (2,) >>> m.numpy() array([1., 1.], dtype=float32) Args: y_true: tensor of true targets. y_pred: tensor of predicted targets. k: (Optional) Number of top elements to look at for computing accuracy. Defaults to 5. Returns: Sparse top K categorical accuracy value. Nrr6rZint32) r rrfrr%rIr)rr*r_r r6)rrrr]r^r;r;r<r srr6cCs.tj||d}tj||d}tj|||dS)a#Computes the cosine similarity between labels and predictions. Args: y_true: The ground truth values. y_pred: The prediction values. axis: (Optional) Defaults to -1. The dimension along which the cosine similarity is computed. Returns: Cosine similarity value. )r)r*Z l2_normalizer)r)rrrr;r;r<cosine_proximitys r`c Cs.t|tr*t|j|SQRX|S)zFReturns a clone of the metric if stateful, otherwise returns it as is.N)rIr1r ror:rr[)metricr;r;r< clone_metrics  rbcCs tt|S)z"Clones the given metric list/dict.)r.Z map_structurerb)Zmetricsr;r;r< clone_metrics$srczkeras.metrics.serializecCst|S)zSerializes metric function or `Metric` instance. Args: metric: A Keras `Metric` instance or a metric function. Returns: Metric configuration dictionary. )r")rar;r;r< serialize)s rdzkeras.metrics.deserializecCst|t|ddS)aBDeserializes a serialized metric class/function instance. Args: config: Metric configuration. custom_objects: Optional dictionary mapping names (strings) to custom objects (classes and functions) to be considered during deserialization. Returns: A Keras `Metric` instance or a metric function. zmetric function)Zmodule_objectscustom_objectsZprintable_module_name)r!globals)rrer;r;r< deserialize6s rgzkeras.metrics.getcCsFt|trt|St|tr(tt|St|r4|Std|dS)aRetrieves a Keras metric as a `function`/`Metric` class instance. The `identifier` may be the string name of a metric function or class. >>> metric = tf.keras.metrics.get("categorical_crossentropy") >>> type(metric) >>> metric = tf.keras.metrics.get("CategoricalCrossentropy") >>> type(metric) You can also specify `config` of the metric to this function by passing dict containing `class_name` and `config` as an identifier. Also note that the `class_name` must map to a `Metric` class >>> identifier = {"class_name": "CategoricalCrossentropy", ... "config": {"from_logits": True}} >>> metric = tf.keras.metrics.get(identifier) >>> type(metric) Args: identifier: A metric identifier. One of None or string name of a metric function/class or metric configuration dictionary or a metric function or a metric class instance Returns: A Keras metric as a `function`/ `Metric` class instance. Raises: ValueError: If `identifier` cannot be interpreted. z2Could not interpret metric function identifier: {}N)rIrrgstrcallablerr) identifierr;r;r<rIs"   rcCs |jtjkS)N)ryr1)rOr;r;r<rGvsrG)r[)r)r)r6)N)r{r}rLr`numpyrZ tensorflow.python.autograph.corerZ tensorflow.python.autograph.implrr>Ztensorflow.python.distributerrlZtensorflow.python.eagerrrZtensorflow.python.frameworkrrr r Ztensorflow.python.kerasr r Ztensorflow.python.keras.enginer rrZtensorflow.python.keras.lossesrrrrrrrrrrrrrZ*tensorflow.python.keras.saving.saved_modelrZtensorflow.python.keras.utilsrrr Z+tensorflow.python.keras.utils.generic_utilsr!r"r#Z&tensorflow.python.keras.utils.tf_utilsr$Ztensorflow.python.opsr%r&r'r(r)r*r+rmr,Ztensorflow.python.utilr-r.Z tensorflow.python.util.tf_exportr/Ztensorflow.tools.docsr0ZLayerABCMetar1rrrrrrrrrrrrrrrrrrrrrrrr r7r9r:r;r<r=r>r?r@rCrDrErFrMrSrUrVrWrYrZadd_dispatch_supportrrrrrr`accZACCZbceZBCEZmseZMSEZmaeZMAEZmapeZMAPEZmsleZMSLEr8Zlog_coshrbrcrdrgrrGr;r;r;r<sX                                               b$)OY),32&%F0000k][PTc1####"%"6##${4?F$ ("   -