code: def confusion_matrix(
      labels,
      predictions,
      num_classes,
      weights=None,
      dtype="int32",
  ):
      """Computes 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
      keras.metrics.metrics_utils.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.
          weights: An optional tensor whose shape matches `predictions`.
          dtype: Data type of the confusion matrix.
  
      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.
      """
      labels = ops.convert_to_tensor(labels, dtype)
      predictions = ops.convert_to_tensor(predictions, dtype)
      labels, predictions = squeeze_to_same_rank(labels, predictions)
  
      predictions = ops.cast(predictions, dtype)
      labels = ops.cast(labels, dtype)
  
      if weights is not None:
          weights = ops.convert_to_tensor(weights, dtype)
  
      indices = ops.stack([labels, predictions], axis=1)
      values = (
          ops.ones_like(predictions, dtype)
          if weights is None
          else weights
      )
      indices = ops.cast(indices, dtype="int64")
      values = ops.cast(values, dtype=dtype)
      num_classes = int(num_classes)
      confusion_matrix = ops.scatter(
          indices, values, (num_classes, num_classes)
      )
      return confusion_matrix
  
imports: from enum import Enum
  import numpy
  from keras import backend
  from keras import ops
  from keras.losses.loss import squeeze_to_same_rank
  from keras.utils.python_utils import to_list
label_desc: Use image node_id 7 for calling a global function with example usage: confusion_matrix(labels, predictions, num_classes, weights, dtype) and returns: confusion_matrix