class_docstr: Calculates a confusion matrix for multi-labelled, multi-class data.
  
  - ``update`` must receive output of the form ``(y_pred, y)``.
  - `y_pred` must contain 0s and 1s and has the following shape (batch_size, num_classes, ...).
    For example, `y_pred[i, j]` = 1 denotes that the j'th class is one of the labels of the i'th sample as predicted.
  - `y` should have the following shape (batch_size, num_classes, ...) with 0s and 1s. For example,
    `y[i, j]` = 1 denotes that the j'th class is one of the labels of the i'th sample according to the ground truth.
  - both `y` and `y_pred` must be torch Tensors having any of the following types:
    {torch.uint8, torch.int8, torch.int16, torch.int32, torch.int64}. They must have the same dimensions.
  - The confusion matrix 'M' is of dimension (num_classes, 2, 2).
  
    * M[i, 0, 0] corresponds to count/rate of true negatives of class i
    * M[i, 0, 1] corresponds to count/rate of false positives of class i
    * M[i, 1, 0] corresponds to count/rate of false negatives of class i
    * M[i, 1, 1] corresponds to count/rate of true positives of class i
  
  - The classes present in M are indexed as 0, ... , num_classes-1 as can be inferred from above.
  
  Args:
      num_classes: Number of classes, should be > 1.
      output_transform: a callable that is used to transform the
          :class:`~ignite.engine.engine.Engine`'s ``process_function``'s output into the
          form expected by the metric. This can be useful if, for example, you have a multi-output model and
          you want to compute the metric with respect to one of the outputs.
      device: specifies which device updates are accumulated on. Setting the metric's
          device to be the same as your ``update`` arguments ensures the ``update`` method is non-blocking. By
          default, CPU.
      normalized: whether to normalize confusion matrix by its sum or not.
  
  Example:
  
      For more information on how metric works with :class:`~ignite.engine.engine.Engine`, visit :ref:`attach-engine`.
  
      .. include:: defaults.rst
          :start-after: :orphan:
  
      .. testcode::
  
          metric = MultiLabelConfusionMatrix(num_classes=3)
          metric.attach(default_evaluator, "mlcm")
          y_true = torch.tensor([
              [0, 0, 1],
              [0, 0, 0],
              [0, 0, 0],
              [1, 0, 0],
              [0, 1, 1],
          ])
          y_pred = torch.tensor([
              [1, 1, 0],
              [1, 0, 1],
              [1, 0, 0],
              [1, 0, 1],
              [1, 1, 0],
          ])
          state = default_evaluator.run([[y_pred, y_true]])
          print(state.metrics["mlcm"])
  
      .. testoutput::
  
          tensor([[[0, 4],
                   [0, 1]],
  
                  [[3, 1],
                   [0, 1]],
  
                  [[1, 2],
                   [2, 0]]])
  
  .. versionadded:: 0.4.5
code: def compute(self) -> torch.Tensor:
      if self._num_examples == 0:
          raise NotComputableError(
              "Confusion matrix must have at least one example before it can be computed."
          )
  
      if self.normalized:
          conf = self.confusion_matrix.to(dtype=torch.float64)
          sums = conf.sum(dim=(1, 2))
          return conf / sums[:, None, None]
  
      return self.confusion_matrix
  
file_path: ignite/ignite/metrics/multilabel_confusion_matrix.py
imports: from typing import Callable, Sequence, Union
  import torch
  from ignite.exceptions import NotComputableError
  from ignite.metrics.metric import Metric, reinit__is_reduced, sync_all_reduce
label_desc: Use image node_id 4 for calling the MultiLabelConfusionMatrix obj's underlying member method code with example usage: obj.compute() and returns: self, unknown