6biroSrSSKJr SSKJr SSKJr SSKJr SSKrSSKJ s J r SSK J r SSKJr SS KJr SS KJr "S S \R*5r\"S 5"SS\55r\"S5"SS\55r\"S5"SS\55r\"S5"SS\55r\"S5"SS\55rg)z IoU metrics.)List)Optional)Tuple)UnionN)backend)utils) base_metric) keras_exportc^\rSrSrSrSS\S\\S\\\\ RR4S\\S\ S\ S \4U4S jjjr SS jrS rS rU=r$)_IoUBase!aComputes the confusion matrix for Intersection-Over-Union metrics. Intersection-Over-Union is a common evaluation metric for semantic image segmentation. For an individual class, the IoU metric is defined as follows: ``` iou = true_positives / (true_positives + false_positives + false_negatives) ``` From IoUs of individual classes, the MeanIoU can be computed as the mean of the individual IoUs. To compute IoUs, 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 size `(num_classes, num_classes)` will be allocated. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. ignore_class: Optional integer. The ID of a class to be ignored during metric computation. This is useful, for example, in segmentation problems featuring a "void" class (commonly -1 or 255) in segmentation maps. By default (`ignore_class=None`), all classes are considered. sparse_y_true: Whether labels are encoded using integers or dense floating point vectors. If `False`, the `tf.argmax` function will be used to determine each sample's most likely associated label. sparse_y_pred: Whether predictions are encoded using integers or dense floating point vectors. If `False`, the `tf.argmax` function will be used to determine each sample's most likely associated label. axis: (Optional) -1 is the dimension containing the logits. Defaults to `-1`. num_classesnamedtype ignore_class sparse_y_true sparse_y_predaxisc>[TU]X#S9 XlX@lXPlX`lXplURSX4SS9Ulg)N)rrtotal_confusion_matrixzeros)shape initializer) super__init__rrrrr add_weighttotal_cm) selfrrrrrrr __class__s Z/home/james-whalen/.local/lib/python3.13/site-packages/tf_keras/src/metrics/iou_metrics.pyr_IoUBase.__init__JsU d0&(**  $,(  c UR(d[R"XRS9nUR(d[R"X RS9n[R "XR 5n[R "X R 5nURRS:a[R"US/5nURRS:a[R"US/5nUbR[R "X0R 5nURRS:a[R"US/5nURbP[R "URUR5n[R"X5nXnX%nUbX5n[RRUUURUUR S9nUR R#U5$)aKAccumulates the confusion matrix statistics. Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Defaults to `1`. Returns: Update op. r)weightsr)rtfargmaxrrcast_dtyperndimsreshaperr not_equalmathconfusion_matrixrr assign_add)ry_truey_pred sample_weightr valid_mask current_cms r update_state_IoUBase.update_statebs!!YYvII6F!!YYvII6F-- <<   !ZZ-F <<   !ZZ-F  $GGM;;?M""((1, " =2$ ?    (774#4#4fllCLf;J'F'F( - 9 WW--     !++ . }}'' 33r"c[R"UR[R"UR UR 455 gN)r set_valuernprrrs r reset_state_IoUBase.reset_states3 MM288T%5%5t7G7G$HI r")rrrrrrNNNTTr&r:)__name__ __module__ __qualname____firstlineno____doc__intrstrrr(dtypesDTypeboolrr7r>__static_attributes__ __classcell__rs@r r r !s&V#7;&*""  sm c299??234  sm       024h  r"r zkeras.metrics.IoUc^\rSrSrSr\R SS\S\\ \\ \S44S\ \ S\ \\ \ RR4S\ \S \S \S \4U4S jjj5rS rU4SjrSrU=r$)IoUa Computes the Intersection-Over-Union metric for specific target classes. General definition and computation: Intersection-Over-Union is a common evaluation metric for semantic image segmentation. For an individual class, the IoU metric is defined as follows: ``` iou = true_positives / (true_positives + false_positives + false_negatives) ``` To compute IoUs, 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. Note, this class first computes IoUs for all individual classes, then returns the mean of IoUs for the classes that are specified by `target_class_ids`. If `target_class_ids` has only one id value, the IoU of that specific class is returned. Args: num_classes: The possible number of labels the prediction task can have. A confusion matrix of dimension = [num_classes, num_classes] will be allocated to accumulate predictions from which the metric is calculated. target_class_ids: A tuple or list of target class ids for which the metric is returned. To compute IoU for a specific class, a list (or tuple) of a single id value should be provided. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. ignore_class: Optional integer. The ID of a class to be ignored during metric computation. This is useful, for example, in segmentation problems featuring a "void" class (commonly -1 or 255) in segmentation maps. By default (`ignore_class=None`), all classes are considered. sparse_y_true: Whether labels are encoded using integers or dense floating point vectors. If `False`, the `tf.argmax` function will be used to determine each sample's most likely associated label. sparse_y_pred: Whether predictions are encoded using integers or dense floating point vectors. If `False`, the `tf.argmax` function will be used to determine each sample's most likely associated label. axis: (Optional) -1 is the dimension containing the logits. Defaults to `-1`. 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)) >>> # iou = [0.33, 0.33] >>> m = tf.keras.metrics.IoU(num_classes=2, target_class_ids=[0]) >>> 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]) >>> # cm = [[0.3, 0.3], >>> # [0.3, 0.1]] >>> # sum_row = [0.6, 0.4], sum_col = [0.6, 0.4], >>> # true_positives = [0.3, 0.1] >>> # iou = [0.33, 0.14] >>> m.result().numpy() 0.33333334 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.IoU(num_classes=2, target_class_ids=[0])]) ``` rtarget_class_ids.rrrrrrc >[T U]UUUUUUUS9 [U5U:a[S[U5SSSUS35e[ U5Ulg)N)rrrrrrrzTarget class id z is out of range, which is [rz, z).)rrmax ValueErrorlistrQ) rrrQrrrrrrrs r r IoU.__init__s~ #%''    K /"3'7#8"9:3b R)  !%%5 6r"c@[R"[R"URSS9URS9n[R"[R"URSS9URS9n[R"[R R UR5URS9nX-U- n[R"X0R5n[R"X@R5n[R"[R"[R"US5URS95n[RRX45n[RR[R"USS9U5$)z=Compute the intersection-over-union via the confusion matrix.rr$)rr%mean_iou)r) r(r* reduce_sumrr+linalgtensor_diag_partgatherrQr.r/ divide_no_nan)r sum_over_row sum_over_coltrue_positives denominatornum_valid_entriesious r result IoU.result s!ww MM$--a 0  ww MM$--a 0   II & &t}} 5T[[  #1NB >3H3HIii -B-BC MM GGBLLa0 D gg##N@ww$$ MM#J /1B  r"c">URURURURURUR S.n[ TU]5n[[UR55[UR55-5$)N)rrQrrrr) rrQrrrrr get_configdictrUitems)rconfig base_configrs r rgIoU.get_config)sv++ $ 5 5 --!//!//II  g(* D**,-V\\^0DDEEr")rQr@)rArBrCrDrE dtensor_utils inject_meshrFrrrrrGr(rHrIrJrrdrgrKrLrMs@r rOrOsM^ #7;&*""77 S 5c? :;7sm 7 c299??234 7 sm 777778 > F Fr"rOzkeras.metrics.BinaryIoUc^\rSrSrSr\R S S\\\ \ \ S444U4Sjjj5r S U4Sjjr Sr SrU=r$) BinaryIoUi6aW Computes the Intersection-Over-Union metric for class 0 and/or 1. General definition and computation: Intersection-Over-Union is a common evaluation metric for semantic image segmentation. For an individual class, the IoU metric is defined as follows: ``` iou = true_positives / (true_positives + false_positives + false_negatives) ``` To compute IoUs, 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. This class can be used to compute IoUs for a binary classification task where the predictions are provided as logits. First a `threshold` is applied to the predicted values such that those that are below the `threshold` are converted to class 0 and those that are above the `threshold` are converted to class 1. IoUs for classes 0 and 1 are then computed, the mean of IoUs for the classes that are specified by `target_class_ids` is returned. Note: with `threshold=0`, this metric has the same behavior as `IoU`. Args: target_class_ids: A tuple or list of target class ids for which the metric is returned. Options are `[0]`, `[1]`, or `[0, 1]`. With `[0]` (or `[1]`), the IoU metric for class 0 (or class 1, respectively) is returned. With `[0, 1]`, the mean of IoUs for the two classes is returned. threshold: A threshold that applies to the prediction logits to convert them to either predicted class 0 if the logit is below `threshold` or predicted class 1 if the logit is above `threshold`. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. Standalone usage: >>> m = tf.keras.metrics.BinaryIoU(target_class_ids=[0, 1], threshold=0.3) >>> m.update_state([0, 1, 0, 1], [0.1, 0.2, 0.4, 0.7]) >>> m.result().numpy() 0.33333334 >>> m.reset_state() >>> m.update_state([0, 1, 0, 1], [0.1, 0.2, 0.4, 0.7], ... sample_weight=[0.2, 0.3, 0.4, 0.1]) >>> # cm = [[0.2, 0.4], >>> # [0.3, 0.1]] >>> # sum_row = [0.6, 0.4], sum_col = [0.5, 0.5], >>> # true_positives = [0.2, 0.1] >>> # iou = [0.222, 0.125] >>> m.result().numpy() 0.17361112 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.BinaryIoU(target_class_ids=[0], threshold=0.5)]) ``` rQ.c2>[TU]SUUUS9 X lg)N)rrQrr)rr threshold)rrQrsrrrs r rBinaryIoU.__init__~s* -  #r"c>[R"X R5n[R"X R:UR5n[TU]XU5$)aAccumulates the confusion matrix statistics. Before the confusion matrix is updated, the predicted values are thresholded to be: 0 for values that are smaller than the `threshold` 1 for values that are larger or equal to the `threshold` Args: y_true: The ground truth values. y_pred: The predicted values. sample_weight: Optional weighting of each example. Can be a `Tensor` whose rank is either 0, or the same rank as `y_true`, and must be broadcastable to `y_true`. Defaults to `1`. Returns: Update op. )r(r*r+rsrr7)rr2r3r4rs r r7BinaryIoU.update_statesD$->>14;;?w#FMBBr"c`URURURURS.$)N)rQrsrr)rQrsrr+r=s r rgBinaryIoU.get_configs* $ 5 5II[[   r")rs))rr%g?NNr:)rArBrCrDrErmrnrrrFrrr7rgrKrLrMs@r rprp6saDL?E  #S 5c? :; # #C,  r"rpzkeras.metrics.MeanIoUc^\rSrSrSr\R S S\S\\ S\\ \ \ RR4S\\S\S\S \4U4S jjj5rS rS rU=r$)MeanIoUia Computes the mean Intersection-Over-Union metric. General definition and computation: Intersection-Over-Union is a common evaluation metric for semantic image segmentation. For an individual class, the IoU metric is defined as follows: ``` iou = true_positives / (true_positives + false_positives + false_negatives) ``` To compute IoUs, 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. Note that this class first computes IoUs for all individual classes, then returns the mean of these 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. ignore_class: Optional integer. The ID of a class to be ignored during metric computation. This is useful, for example, in segmentation problems featuring a "void" class (commonly -1 or 255) in segmentation maps. By default (`ignore_class=None`), all classes are considered. sparse_y_true: Whether labels are encoded using integers or dense floating point vectors. If `False`, the `tf.argmax` function will be used to determine each sample's most likely associated label. sparse_y_pred: Whether predictions are encoded using integers or dense floating point vectors. If `False`, the `tf.argmax` function will be used to determine each sample's most likely associated label. axis: (Optional) The dimension containing the logits. Defaults to `-1`. 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)]) ``` rrrrrrrc V>[[U55n[T U] UUUUUUUUS9 g)N)rrrQrrrrr)rUrangerr) rrrrrrrrrQrs r rMeanIoU.__init__s? k 23 #-%''  r"cURURURURURUR UR S.$)N)rrrrrrr)rrr+rrrrr=s r rgMeanIoU.get_config sE++II[[ --!//!//II  r"r@)rArBrCrDrErmrnrFrrGrr(rHrIrJrrgrKrLrMs@r rzrzsBH#7;&*""  sm c299??234  sm       ,   r"rzzkeras.metrics.OneHotIoUc ^\rSrSrSr\R S S\S\\ \\ \S44S\ \S\ S\4 U4S jjj5r S rS rU=r$) OneHotIoUia Computes the Intersection-Over-Union metric for one-hot encoded labels. General definition and computation: Intersection-Over-Union is a common evaluation metric for semantic image segmentation. For an individual class, the IoU metric is defined as follows: ``` iou = true_positives / (true_positives + false_positives + false_negatives) ``` To compute IoUs, 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. This class can be used to compute IoU for multi-class classification tasks where the labels are one-hot encoded (the last axis should have one dimension per class). Note that the predictions should also have the same shape. To compute the IoU, first the labels and predictions are converted back into integer format by taking the argmax over the class axis. Then the same computation steps as for the base `IoU` class apply. Note, if there is only one channel in the labels and predictions, this class is the same as class `IoU`. In this case, use `IoU` instead. Also, make sure that `num_classes` is equal to the number of classes in the data, to avoid a "labels out of bound" error when the confusion matrix is computed. Args: num_classes: The possible number of labels the prediction task can have. A confusion matrix of shape `(num_classes, num_classes)` will be allocated to accumulate predictions from which the metric is calculated. target_class_ids: A tuple or list of target class ids for which the metric is returned. To compute IoU for a specific class, a list (or tuple) of a single id value should be provided. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. ignore_class: Optional integer. The ID of a class to be ignored during metric computation. This is useful, for example, in segmentation problems featuring a "void" class (commonly -1 or 255) in segmentation maps. By default (`ignore_class=None`), all classes are considered. sparse_y_pred: Whether predictions are encoded using natural numbers or probability distribution vectors. If `False`, the `tf.argmax` function will be used to determine each sample's most likely associated label. axis: (Optional) The dimension containing the logits. Defaults to `-1`. Standalone usage: >>> y_true = tf.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 0, 0]]) >>> y_pred = tf.constant([[0.2, 0.3, 0.5], [0.1, 0.2, 0.7], [0.5, 0.3, 0.1], ... [0.1, 0.4, 0.5]]) >>> sample_weight = [0.1, 0.2, 0.3, 0.4] >>> m = tf.keras.metrics.OneHotIoU(num_classes=3, target_class_ids=[0, 2]) >>> m.update_state( ... y_true=y_true, y_pred=y_pred, sample_weight=sample_weight) >>> # cm = [[0, 0, 0.2+0.4], >>> # [0.3, 0, 0], >>> # [0, 0, 0.1]] >>> # sum_row = [0.3, 0, 0.7], sum_col = [0.6, 0.3, 0.1] >>> # true_positives = [0, 0, 0.1] >>> # single_iou = true_positives / (sum_row + sum_col - true_positives)) >>> # mean_iou = (0 / (0.3 + 0.6 - 0) + 0.1 / (0.7 + 0.1 - 0.1)) / 2 >>> m.result().numpy() 0.071 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.OneHotIoU(num_classes=3, target_class_id=[1])]) ``` rrQ.rrrc .>[TU]UUUUUSUUS9 g)NF)rrQrrrrrrrr) rrrQrrrrrrs r rOneHotIoU.__init__hs/ #-%'  r"cURURURURURUR UR S.$)N)rrQrrrrr)rrQrr+rrrr=s r rgOneHotIoU.get_config~sE++ $ 5 5II[[ --!//II  r"rNNNFr&)rArBrCrDrErmrnrFrrrrrJrrgrKrLrMs@r rrsN` &*#   S 5c? :; sm     *   r"rzkeras.metrics.OneHotMeanIoUc^\rSrSrSr\R S S\S\S\ \ \\ RR4S\ \S\S\4 U4S jjj5rS rS rU=r$) OneHotMeanIoUia< Computes mean Intersection-Over-Union metric for one-hot encoded labels. General definition and computation: Intersection-Over-Union is a common evaluation metric for semantic image segmentation. For an individual class, the IoU metric is defined as follows: ``` iou = true_positives / (true_positives + false_positives + false_negatives) ``` To compute IoUs, 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. This class can be used to compute the mean IoU for multi-class classification tasks where the labels are one-hot encoded (the last axis should have one dimension per class). Note that the predictions should also have the same shape. To compute the mean IoU, first the labels and predictions are converted back into integer format by taking the argmax over the class axis. Then the same computation steps as for the base `MeanIoU` class apply. Note, if there is only one channel in the labels and predictions, this class is the same as class `MeanIoU`. In this case, use `MeanIoU` instead. Also, make sure that `num_classes` is equal to the number of classes in the data, to avoid a "labels out of bound" error when the confusion matrix is computed. Args: num_classes: The possible number of labels the prediction task can have. A confusion matrix of shape `(num_classes, num_classes)` will be allocated to accumulate predictions from which the metric is calculated. name: (Optional) string name of the metric instance. dtype: (Optional) data type of the metric result. ignore_class: Optional integer. The ID of a class to be ignored during metric computation. This is useful, for example, in segmentation problems featuring a "void" class (commonly -1 or 255) in segmentation maps. By default (`ignore_class=None`), all classes are considered. sparse_y_pred: Whether predictions are encoded using natural numbers or probability distribution vectors. If `False`, the `tf.argmax` function will be used to determine each sample's most likely associated label. axis: (Optional) The dimension containing the logits. Defaults to `-1`. Standalone usage: >>> y_true = tf.constant([[0, 0, 1], [1, 0, 0], [0, 1, 0], [1, 0, 0]]) >>> y_pred = tf.constant([[0.2, 0.3, 0.5], [0.1, 0.2, 0.7], [0.5, 0.3, 0.1], ... [0.1, 0.4, 0.5]]) >>> sample_weight = [0.1, 0.2, 0.3, 0.4] >>> m = tf.keras.metrics.OneHotMeanIoU(num_classes=3) >>> m.update_state( ... y_true=y_true, y_pred=y_pred, sample_weight=sample_weight) >>> # cm = [[0, 0, 0.2+0.4], >>> # [0.3, 0, 0], >>> # [0, 0, 0.1]] >>> # sum_row = [0.3, 0, 0.7], sum_col = [0.6, 0.3, 0.1] >>> # true_positives = [0, 0, 0.1] >>> # single_iou = true_positives / (sum_row + sum_col - true_positives)) >>> # mean_iou = (0 + 0 + 0.1 / (0.7 + 0.1 - 0.1)) / 3 >>> m.result().numpy() 0.048 Usage with `compile()` API: ```python model.compile( optimizer='sgd', loss='mse', metrics=[tf.keras.metrics.OneHotMeanIoU(num_classes=3)]) ``` rrrrrrc ,>[TU]UUUUUSUS9 g)NF)rrrrrrrr)rrrrrrrrs r rOneHotMeanIoU.__init__s, #%'  r"cURURURURURUR S.$)N)rrrrrr)rrr+rrrr=s r rgOneHotMeanIoU.get_configs<++II[[ --!//II   r"rr)rArBrCrDrErmrnrFrGrrr(rHrIrJrrgrKrLrMs@r rrsL\7;&*#   c299??234  sm      &  r"r)rEtypingrrrrnumpyr<tensorflow.compat.v2compatv2r( tf_keras.srcrtf_keras.src.dtensorrrmtf_keras.src.metricsr tensorflow.python.util.tf_exportr Metricr rOrprzrrrr"r rs!! 7,:x {!!x v!"VF(VF#VFr'(s s )s l%&e ce 'e P'(p p )p f+,k Gk -k r"