code: def hamming_loss(y_true, y_pred, *, sample_weight=None):
      """Compute the average Hamming loss.
  
      The Hamming loss is the fraction of labels that are incorrectly predicted.
  
      Read more in the :ref:`User Guide <hamming_loss>`.
  
      Parameters
      ----------
      y_true : 1d array-like, or label indicator array / sparse matrix
          Ground truth (correct) labels.
  
      y_pred : 1d array-like, or label indicator array / sparse matrix
          Predicted labels, as returned by a classifier.
  
      sample_weight : array-like of shape (n_samples,), default=None
          Sample weights.
  
          .. versionadded:: 0.18
  
      Returns
      -------
      loss : float or int
          Return the average Hamming loss between element of ``y_true`` and
          ``y_pred``.
  
      See Also
      --------
      accuracy_score : Compute the accuracy score. By default, the function will
          return the fraction of correct predictions divided by the total number
          of predictions.
      jaccard_score : Compute the Jaccard similarity coefficient score.
      zero_one_loss : Compute the Zero-one classification loss. By default, the
          function will return the percentage of imperfectly predicted subsets.
  
      Notes
      -----
      In multiclass classification, the Hamming loss corresponds to the Hamming
      distance between ``y_true`` and ``y_pred`` which is equivalent to the
      subset ``zero_one_loss`` function, when `normalize` parameter is set to
      True.
  
      In multilabel classification, the Hamming loss is different from the
      subset zero-one loss. The zero-one loss considers the entire set of labels
      for a given sample incorrect if it does not entirely match the true set of
      labels. Hamming loss is more forgiving in that it penalizes only the
      individual labels.
  
      The Hamming loss is upperbounded by the subset zero-one loss, when
      `normalize` parameter is set to True. It is always between 0 and 1,
      lower being better.
  
      References
      ----------
      .. [1] Grigorios Tsoumakas, Ioannis Katakis. Multi-Label Classification:
             An Overview. International Journal of Data Warehousing & Mining,
             3(3), 1-13, July-September 2007.
  
      .. [2] `Wikipedia entry on the Hamming distance
             <https://en.wikipedia.org/wiki/Hamming_distance>`_.
  
      Examples
      --------
      >>> from sklearn.metrics import hamming_loss
      >>> y_pred = [1, 2, 3, 4]
      >>> y_true = [2, 2, 3, 4]
      >>> hamming_loss(y_true, y_pred)
      0.25
  
      In the multilabel case with binary label indicators:
  
      >>> import numpy as np
      >>> hamming_loss(np.array([[0, 1], [1, 1]]), np.zeros((2, 2)))
      0.75
      """
  
      y_type, y_true, y_pred = _check_targets(y_true, y_pred)
      check_consistent_length(y_true, y_pred, sample_weight)
  
      if sample_weight is None:
          weight_average = 1.0
      else:
          weight_average = np.mean(sample_weight)
  
      if y_type.startswith("multilabel"):
          n_differences = count_nonzero(
              y_true - y_pred, sample_weight=sample_weight
          )
          return n_differences / (
              y_true.shape[0] * y_true.shape[1] * weight_average
          )
  
      elif y_type in ["binary", "multiclass"]:
          return _weighted_sum(
              y_true != y_pred, sample_weight, normalize=True
          )
      else:
          raise ValueError("{0} is not supported".format(y_type))
  
imports: import warnings
  from numbers import Integral, Real
  import numpy
  from scipy.sparse import coo_matrix, csr_matrix
  from scipy.special import xlogy
  from ..exceptions import UndefinedMetricWarning
  from ..preprocessing import LabelBinarizer, LabelEncoder
  from ..utils import assert_all_finite, check_array, check_consistent_length, column_or_1d
  from ..utils._param_validation import Interval, Options, StrOptions, validate_params
  from ..utils.extmath import _nanaverage
  from ..utils.multiclass import type_of_target, unique_labels
  from ..utils.sparsefuncs import count_nonzero
  from ..utils.validation import _check_pos_label_consistency, _num_samples
label_desc: Use image node_id 22 for calling a global function with example usage: hamming_loss(y_true, y_pred) and returns: unknown, _weighted_sum