code: def accuracy_score(
      y_true,
      y_pred,
      normalize=True,
      sample_weight=None,
      session=None,
      run_kwargs=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 tensor / sparse tensor
          Ground truth (correct) labels.
  
      y_pred : 1d array-like, or label indicator tensor / sparse tensor
          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,), default=None
          Sample weights.
  
      Returns
      -------
      score : float
          If ``normalize == True``, return the fraction of correctly
          classified samples (float), else 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_score, hamming_loss, zero_one_loss
  
      Notes
      -----
      In binary and multiclass classification, this function is equal
      to the ``jaccard_score`` function.
  
      Examples
      --------
      >>> from mars.learn.metrics import accuracy_score
      >>> y_pred = [0, 2, 1, 3]
      >>> y_true = [0, 1, 2, 3]
      >>> accuracy_score(y_true, y_pred).execute()
      0.5
      >>> accuracy_score(y_true, y_pred, normalize=False).execute()
      2
  
      In the multilabel case with binary label indicators:
  
      >>> import mars.tensor as mt
      >>> accuracy_score(mt.array([[0, 1], [1, 1]]), mt.ones((2, 2))).execute()
      0.5
      """
  
      # Compute accuracy for each possible representation
      op = AccuracyScore(
          y_true=y_true,
          y_pred=y_pred,
          normalize=normalize,
          sample_weight=sample_weight,
      )
      score = op(y_true, y_pred)
      return score.execute(session=session, **(run_kwargs or dict()))
  
imports: import warnings
  import numpy
  from sklearn.exceptions import UndefinedMetricWarning
  from ...None import execute, fetch
  from ...None import opcodes
  from ...None import tensor
  from ...core import ENTITY_TYPE, recursive_tile
  from ...core.context import get_context
  from ...serialization.serializables import AnyField, BoolField, KeyField
  from ...tensor.core import TensorOrder
  from ..operands import LearnOperand, LearnOperandMixin, OutputType
  from ..preprocessing import LabelBinarizer, LabelEncoder
  from ..utils import check_array, check_consistent_length, column_or_1d
  from ..utils.multiclass import unique_labels
  from ..utils.sparsefuncs import count_nonzero
  from ._check_targets import _check_targets
label_desc: Use image node_id 2 for calling a global function with example usage: accuracy_score(y_true, y_pred, normalize, sample_weight, session, run_kwargs) and returns: score