code: def accuracy_score(
      y_true, y_pred, normalize=True, sample_weight=None
  ):
      """Accuracy classification score.
  
      In multilabel classification, this function computes subset accuracy:
      the set of labels predicted for a sample must *exactly* match the
      corresponding set of labels in y_true.
  
      Read more in the :ref:`User Guide <accuracy_score>`.
  
      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.
  
      normalize : bool, optional (default=True)
          If ``False``, return the number of correctly classified samples.
          Otherwise, return the fraction of correctly classified samples.
  
      sample_weight : array-like of shape = [n_samples], optional
          Sample weights.
  
      Returns
      -------
      score : float
          If ``normalize == True``, return the correctly classified samples
          (float), else it returns the number of correctly classified samples
          (int).
  
          The best performance is 1 with ``normalize == True`` and the number
          of samples with ``normalize == False``.
  
      See also
      --------
      jaccard_similarity_score, hamming_loss, zero_one_loss
  
      Notes
      -----
      In binary and multiclass classification, this function is equal
      to the ``jaccard_similarity_score`` function.
  
      Examples
      --------
      >>> import numpy as np
      >>> from sklearn.metrics import accuracy_score
      >>> y_pred = [0, 2, 1, 3]
      >>> y_true = [0, 1, 2, 3]
      >>> accuracy_score(y_true, y_pred)
      0.5
      >>> accuracy_score(y_true, y_pred, normalize=False)
      2
  
      In the multilabel case with binary label indicators:
      >>> accuracy_score(np.array([[0, 1], [1, 1]]), np.ones((2, 2)))
      0.5
      """
  
      # Compute accuracy for each possible representation
      y_type, y_true, y_pred = _check_targets(y_true, y_pred)
      if y_type.startswith("multilabel"):
          differing_labels = count_nonzero(y_true - y_pred, axis=1)
          score = differing_labels == 0
      else:
          score = y_true == y_pred
  
      return _weighted_sum(score, sample_weight, normalize)
  
imports: from __future__ import division
  import warnings
  import numpy
  from scipy.sparse import coo_matrix
  from scipy.sparse import csr_matrix
  from ..preprocessing import LabelBinarizer, label_binarize
  from ..preprocessing import LabelEncoder
  from ..utils import assert_all_finite
  from ..utils import check_array
  from ..utils import check_consistent_length
  from ..utils import column_or_1d
  from ..utils.multiclass import unique_labels
  from ..utils.multiclass import type_of_target
  from ..utils.validation import _num_samples
  from ..utils.sparsefuncs import count_nonzero
  from ..utils.fixes import bincount
  from ..exceptions import UndefinedMetricWarning
label_desc: Use image node_id 3 for calling a global function with example usage: accuracy_score(y_true, y_pred, normalize, sample_weight) and returns: _weighted_sum