AVh)|dZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z dd lm Z dd l m Z dd l m Z dd lmZ ddZedge j"d d ej$d fdZeddge j"e j(ddd ej$d d fdZy )z#Confusion matrix related utilities.)dtypes)ops) array_ops)array_ops_stack) check_ops)cond)control_flow_ops)math_ops) deprecation)dispatch) tf_exportNctj|dg5tjtjj}|j}j}|j}||||z }||dzk(r6|j dj drtjdgn=||dz k(r5|j dj drtjdgfcdddStjtjz }||j dj dr4tjtj|dz|fdfd||j dj dr4tjtj|dz |fdfdfcdddS#1swYyxYw) a$Squeeze last dim if ranks differ from expected by exactly 1. In the common case where we expect shapes to match, `expected_rank_diff` defaults to 0, and we squeeze the last dimension of the larger rank if they differ by 1. But, for example, if `labels` contains class IDs and `predictions` contains 1 probability per class, we expect `predictions` to have 1 more dimension than `labels`, so `expected_rank_diff` would be 1. In this case, we'd squeeze `labels` if `rank(predictions) - rank(labels) == 0`, and `predictions` if `rank(predictions) - rank(labels) == 2`. This will use static shape if available. Otherwise, it will add graph operations, which could result in a performance hit. Args: labels: Label values, a `Tensor` whose dimensions match `predictions`. predictions: Predicted values, a `Tensor` of arbitrary dimensions. expected_rank_diff: Expected result of `rank(predictions) - rank(labels)`. name: Name of the op. Returns: Tuple of `labels` and `predictions`, possibly with last dim squeezed. remove_squeezable_dimensionsNc2tjdgSNrrsqueeze predictionssV/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/confusion_matrix.pyz.remove_squeezable_dimensions..Qs)##K"6cSNrsrrz.remove_squeezable_dimensions..Rs+rc2tjdgSrrlabelssrrz.remove_squeezable_dimensions..Ws)##FRD1rcSrrrsrrz.remove_squeezable_dimensions..Xs&r) r name_scopeconvert_to_tensor get_shapendimsdimsis_compatible_withrrrankrr equal) r rexpected_rank_diffnamepredictions_shapepredictions_rank labels_shape labels_rank rank_diffs `` rrrs4 ~~d:{+-!'' 4K  " "6 *F#--/(..##%L$$K&6&B"[0i )A- -   $ 7 7 :'' bT: +a/ /   b ! 4 4Q 7""6B40 [ #!!({+innV.DDI r"55a8II ..+a/ ; 6 k "003yy ..+a/ ; 1 f ; C!!!sC*G0CG00G9zmath.confusion_matrix)v1c Vtj|d||||f5}ttj|dtj|d\}}t j |t j}t j |t j}tjtj|dg|}tjtj|dg|}|@t jt j|t j|d z}n~t j |t j}tjtj||d g|}tjtj||d g|}|Ztj|d }|jj!|jt j ||}t#j$||g}t#j$||gd }|t'j(||n|} t'j*|| t j |t jcdddS#1swYyxYw)aComputes the confusion matrix from predictions and labels. The matrix columns represent the prediction labels and the rows represent the real labels. The confusion matrix is always a 2-D array of shape `[n, n]`, where `n` is the number of valid labels for a given classification task. Both prediction and labels must be 1-D arrays of the same shape in order for this function to work. If `num_classes` is `None`, then `num_classes` will be set to one plus the maximum value in either predictions or labels. Class labels are expected to start at 0. For example, if `num_classes` is 3, then the possible labels would be `[0, 1, 2]`. If `weights` is not `None`, then each prediction contributes its corresponding weight to the total value of the confusion matrix cell. For example: ```python tf.math.confusion_matrix([1, 2, 4], [2, 2, 4]) ==> [[0 0 0 0 0] [0 0 1 0 0] [0 0 1 0 0] [0 0 0 0 0] [0 0 0 0 1]] ``` Note that the possible labels are assumed to be `[0, 1, 2, 3, 4]`, resulting in a 5x5 confusion matrix. Args: labels: 1-D `Tensor` of real labels for the classification task. predictions: 1-D `Tensor` of predictions for a given classification. num_classes: The possible number of labels the classification task can have. If this value is not provided, it will be calculated using both predictions and labels array. weights: An optional `Tensor` whose shape matches `predictions`. dtype: Data type of the confusion matrix. name: Scope name. Returns: A `Tensor` of type `dtype` with shape `[n, n]` representing the confusion matrix, where `n` is the number of possible labels in the classification task. Raises: ValueError: If both predictions and labels are not 1-D vectors and have mismatched shapes, or if `weights` is not `None` and its shape doesn't match `predictions`. confusion_matrixr )r+rz!`labels` contains negative values)messagez&`predictions` contains negative valuesNrz`labels` out of boundz`predictions` out of boundweights)axis)indicesupdatesshape)rr"rr#r castrint64r with_dependenciesrassert_non_negativemaximum reduce_max assert_lessr$assert_is_compatible_withrstackr ones_like scatter_nd) r r num_classesr5dtyper+num_classes_int64r9r7valuess rr3r3\skt ~~d."FKAC.2FJ6 f84  m -.FK-- V\\:K ]]66<< 0F / /  & & ? A BF#44  & & !I K LK $$X%8%8%E%-%8%8%@BDEFk#-- V\\B11  '1H J K f%66  ,2 4 5  k %%gI>g778I8I8KL gu-g  ! !; "< =E##V[$9BG!!+u5&-   mmE6<<0 2W.2.2.2s I9JJ(r3ztrain.confusion_matrixc"t||||||S)aComputes the confusion matrix from predictions and labels. The matrix columns represent the prediction labels and the rows represent the real labels. The confusion matrix is always a 2-D array of shape `[n, n]`, where `n` is the number of valid labels for a given classification task. Both prediction and labels must be 1-D arrays of the same shape in order for this function to work. If `num_classes` is `None`, then `num_classes` will be set to one plus the maximum value in either predictions or labels. Class labels are expected to start at 0. For example, if `num_classes` is 3, then the possible labels would be `[0, 1, 2]`. If `weights` is not `None`, then each prediction contributes its corresponding weight to the total value of the confusion matrix cell. For example: ```python tf.math.confusion_matrix([1, 2, 4], [2, 2, 4]) ==> [[0 0 0 0 0] [0 0 1 0 0] [0 0 1 0 0] [0 0 0 0 0] [0 0 0 0 1]] ``` Note that the possible labels are assumed to be `[0, 1, 2, 3, 4]`, resulting in a 5x5 confusion matrix. Args: labels: 1-D `Tensor` of real labels for the classification task. predictions: 1-D `Tensor` of predictions for a given classification. num_classes: The possible number of labels the classification task can have. If this value is not provided, it will be calculated using both predictions and labels array. dtype: Data type of the confusion matrix. name: Scope name. weights: An optional `Tensor` whose shape matches `predictions`. Returns: A `Tensor` of type `dtype` with shape `[n, n]` representing the confusion matrix, where `n` is the number of possible labels in the classification task. Raises: ValueError: If both predictions and labels are not 1-D vectors and have mismatched shapes, or if `weights` is not `None` and its shape doesn't match `predictions`. )r3)r rrErFr+r5s rconfusion_matrix_v1rJsv &+{GU  r)rN)__doc__tensorflow.python.frameworkrrtensorflow.python.opsrrrrr r tensorflow.python.utilr r tensorflow.python.util.tf_exportr radd_dispatch_supportint32r3deprecated_endpointsrJrrrrSs*.++1+&2*.+659;| "r* "&!!<< f2+f2R &(:;< !!!"46NO%)$ll! $ 9 P=9 r