code: def jaccard_similarity_score(
      y_true, y_pred, normalize=True, sample_weight=None
  ):
      """Jaccard similarity coefficient score
  
      The Jaccard index [1], or Jaccard similarity coefficient, defined as
      the size of the intersection divided by the size of the union of two label
      sets, is used to compare set of predicted labels for a sample to the
      corresponding set of labels in ``y_true``.
  
      Read more in the :ref:`User Guide <jaccard_similarity_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 sum of the Jaccard similarity coefficient
          over the sample set. Otherwise, return the average of Jaccard
          similarity coefficient.
  
      sample_weight : array-like of shape = [n_samples], optional
          Sample weights.
  
      Returns
      -------
      score : float
          If ``normalize == True``, return the average Jaccard similarity
          coefficient, else it returns the sum of the Jaccard similarity
          coefficient over the sample set.
  
          The best performance is 1 with ``normalize == True`` and the number
          of samples with ``normalize == False``.
  
      See also
      --------
      accuracy_score, hamming_loss, zero_one_loss
  
      Notes
      -----
      In binary and multiclass classification, this function is equivalent
      to the ``accuracy_score``. It differs in the multilabel classification
      problem.
  
      References
      ----------
      .. [1] `Wikipedia entry for the Jaccard index
             <https://en.wikipedia.org/wiki/Jaccard_index>`_
  
  
      Examples
      --------
      >>> import numpy as np
      >>> from sklearn.metrics import jaccard_similarity_score
      >>> y_pred = [0, 2, 1, 3]
      >>> y_true = [0, 1, 2, 3]
      >>> jaccard_similarity_score(y_true, y_pred)
      0.5
      >>> jaccard_similarity_score(y_true, y_pred, normalize=False)
      2
  
      In the multilabel case with binary label indicators:
  
      >>> jaccard_similarity_score(np.array([[0, 1], [1, 1]]),\
          np.ones((2, 2)))
      0.75
      """
  
      # Compute accuracy for each possible representation
      y_type, y_true, y_pred = _check_targets(y_true, y_pred)
      if y_type.startswith("multilabel"):
          with np.errstate(divide="ignore", invalid="ignore"):
              # oddly, we may get an "invalid" rather than a "divide" error here
              pred_or_true = count_nonzero(y_true + y_pred, axis=1)
              pred_and_true = count_nonzero(
                  y_true.multiply(y_pred), axis=1
              )
              score = pred_and_true / pred_or_true
  
              # If there is no label, it results in a Nan instead, we set
              # the jaccard to 1: lim_{x->0} x/x = 1
              # Note with py2.6 and np 1.3: we can't check safely for nan.
              score[pred_or_true == 0.0] = 1.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 6 for calling a global function with example usage: jaccard_similarity_score(y_true, y_pred, normalize, sample_weight) and returns: _weighted_sum