o 7?e^D@sdZddlmmZddlmZddlmZ ddl m Z ddl m Z ddlmZedGd d d e jZed Gd d d e jZedGddde jZedGddde jZdZeej_edGddde jZedGddde jZeej_ddZedejjjd.dd Zed!ejjjd"d#Zed$ejjjd%d&Zed'ejjjd/d)d*Z ed+ejjjd/d,d-Z!dS)0zAccuracy metrics.N)backend)utils) base_metric) metrics_utils) keras_exportzkeras.metrics.Accuracyc(eZdZdZejdfdd ZZS)Accuracya9Calculates 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()]) ``` accuracyNcstjt||ddSNdtype)super__init__r selfnamer  __class__c/home/www/facesmatcher.com/pyenv/lib/python3.10/site-packages/keras/src/metrics/accuracy_metrics.pyrBszAccuracy.__init__)r N__name__ __module__ __qualname____doc__ dtensor_utilsZ inject_meshr __classcell__rrrrrs$rzkeras.metrics.BinaryAccuracyc(eZdZdZejdfdd 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?cstjtj|||ddS)N)r threshold)r rrbinary_matches)rrr r!rrrros  zBinaryAccuracy.__init__)rNr rrrrrrGs&rz!keras.metrics.CategoricalAccuracycr)CategoricalAccuracyaCalculates 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_accuracyNcstjdd||ddS)NcSttjj|dd|SNZaxisrsparse_categorical_matchestfmathargmaxy_truey_predrrrsz.CategoricalAccuracy.__init__..r r rrrrrrs  zCategoricalAccuracy.__init__)r$Nrrrrrr#vs.r#z'keras.metrics.SparseCategoricalAccuracycr)SparseCategoricalAccuracya7Calculates 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_accuracyNcstjtj||ddSr )r rrr*rrrrrs z"SparseCategoricalAccuracy.__init__)r4Nrrrrrr3s,r3aAccumulates metric statistics. For sparse categorical metrics, the shapes of `y_true` and `y_pred` are different. Args: y_true: Ground truth label values. shape = `[batch_size, d0, .. dN-1]` or shape = `[batch_size, d0, .. dN-1, 1]`. y_pred: The predicted probability 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. z%keras.metrics.TopKCategoricalAccuracycr)TopKCategoricalAccuracyaComputes 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_accuracyNcstjdd|||ddS)NcSttjj|dd||Sr&r sparse_top_k_categorical_matchesr+r,r-)ZytZypkrrrr1'sz2TopKCategoricalAccuracy.__init__..r r;r2rr;rr rrrr$s  z TopKCategoricalAccuracy.__init__)r6r7Nrrrrrr5s r5z+keras.metrics.SparseTopKCategoricalAccuracycs*eZdZdZej dfdd ZZS)SparseTopKCategoricalAccuracyaPComputes 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()]) ``` r6!sparse_top_k_categorical_accuracyNcstjtj|||ddS)Nr<)r rrr:r=rrrrQs  z&SparseTopKCategoricalAccuracy.__init__)r6r?Nrrrrrr>0s r>cCsVt||g\\}}}|j|j|j|jkrt||j}tt||t S)N) rZ,ragged_assert_compatible_and_get_flat_valuesshapeZassert_is_compatible_withr r+castequalrZfloatx)r/r0_rrrr bs r zkeras.metrics.binary_accuracyr cCstjt|||ddS)aCalculates 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]` r'r()r+Z reduce_meanrr")r/r0r!rrrrosrz"keras.metrics.categorical_accuracycCr%)a;Calculates 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. r'r(r)r.rrrr$sr$z)keras.metrics.sparse_categorical_accuracycCs8t||}|jjdkr|jddkrt|dg}|S)a9Calculates 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. r')rr*r@Zndimsr+Zsqueeze)r/r0matchesrrrr4s r4z(keras.metrics.top_k_categorical_accuracyr6cCr8)aGComputes 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. r'r(r9r/r0r;rrrr7sr7z/keras.metrics.sparse_top_k_categorical_accuracycCst|||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. )rr:rFrrrr?sr?)r )r6)"rZtensorflow.compat.v2compatv2r+Z keras.srcrZkeras.src.dtensorrrZkeras.src.metricsrZkeras.src.utilsrZ tensorflow.python.util.tf_exportrZMeanMetricWrapperrrr#r3Z*_SPARSE_CATEGORICAL_UPDATE_STATE_DOCSTRINGZ update_stater5r>r Z __internal__dispatchZadd_dispatch_supportrr$r4r7r?rrrrsP     *.:4--   #