code: def fbeta_score(
      y_true,
      y_pred,
      *,
      beta,
      labels=None,
      pos_label=1,
      average="binary",
      sample_weight=None,
      zero_division="warn",
  ):
      """Compute the F-beta score
  
      The F-beta score is the weighted harmonic mean of precision and recall,
      reaching its optimal value at 1 and its worst value at 0.
  
      The `beta` parameter determines the weight of recall in the combined
      score. ``beta < 1`` lends more weight to precision, while ``beta > 1``
      favors recall (``beta -> 0`` considers only precision, ``beta -> +inf``
      only recall).
  
      Read more in the :ref:`User Guide <precision_recall_f_measure_metrics>`.
  
      Parameters
      ----------
      y_true : 1d array-like, or label indicator array / sparse matrix
          Ground truth (correct) target values.
  
      y_pred : 1d array-like, or label indicator array / sparse matrix
          Estimated targets as returned by a classifier.
  
      beta : float
          Determines the weight of recall in the combined score.
  
      labels : list, optional
          The set of labels to include when ``average != 'binary'``, and their
          order if ``average is None``. Labels present in the data can be
          excluded, for example to calculate a multiclass average ignoring a
          majority negative class, while labels not present in the data will
          result in 0 components in a macro average. For multilabel targets,
          labels are column indices. By default, all labels in ``y_true`` and
          ``y_pred`` are used in sorted order.
  
      pos_label : str or int, 1 by default
          The class to report if ``average='binary'`` and the data is binary.
          If the data are multiclass or multilabel, this will be ignored;
          setting ``labels=[pos_label]`` and ``average != 'binary'`` will report
          scores for that label only.
  
      average : string, [None, 'binary' (default), 'micro', 'macro', 'samples', \
                         'weighted']
          This parameter is required for multiclass/multilabel targets.
          If ``None``, the scores for each class are returned. Otherwise, this
          determines the type of averaging performed on the data:
  
          ``'binary'``:
              Only report results for the class specified by ``pos_label``.
              This is applicable only if targets (``y_{true,pred}``) are binary.
          ``'micro'``:
              Calculate metrics globally by counting the total true positives,
              false negatives and false positives.
          ``'macro'``:
              Calculate metrics for each label, and find their unweighted
              mean.  This does not take label imbalance into account.
          ``'weighted'``:
              Calculate metrics for each label, and find their average weighted
              by support (the number of true instances for each label). This
              alters 'macro' to account for label imbalance; it can result in an
              F-score that is not between precision and recall.
          ``'samples'``:
              Calculate metrics for each instance, and find their average (only
              meaningful for multilabel classification where this differs from
              :func:`accuracy_score`).
  
      sample_weight : array-like of shape (n_samples,), default=None
          Sample weights.
  
      zero_division : "warn", 0 or 1, default="warn"
          Sets the value to return when there is a zero division, i.e. when all
          predictions and labels are negative. If set to "warn", this acts as 0,
          but warnings are also raised.
  
      Returns
      -------
      fbeta_score : float (if average is not None) or array of float, shape =\
          [n_unique_labels]
          F-beta score of the positive class in binary classification or weighted
          average of the F-beta score of each class for the multiclass task.
  
      See also
      --------
      precision_recall_fscore_support, multilabel_confusion_matrix
  
      References
      ----------
      .. [1] R. Baeza-Yates and B. Ribeiro-Neto (2011).
             Modern Information Retrieval. Addison Wesley, pp. 327-328.
  
      .. [2] `Wikipedia entry for the F1-score
             <https://en.wikipedia.org/wiki/F1_score>`_
  
      Examples
      --------
      >>> from mars.learn.metrics import fbeta_score
      >>> y_true = [0, 1, 2, 0, 1, 2]
      >>> y_pred = [0, 2, 1, 0, 0, 1]
      >>> fbeta_score(y_true, y_pred, average='macro', beta=0.5)
      0.23...
      >>> fbeta_score(y_true, y_pred, average='micro', beta=0.5)
      0.33...
      >>> fbeta_score(y_true, y_pred, average='weighted', beta=0.5)
      0.23...
      >>> fbeta_score(y_true, y_pred, average=None, beta=0.5)
      array([0.71..., 0.        , 0.        ])
  
      Notes
      -----
      When ``true positive + false positive == 0`` or
      ``true positive + false negative == 0``, f-score returns 0 and raises
      ``UndefinedMetricWarning``. This behavior can be
      modified with ``zero_division``.
      """
  
      _, _, f, _ = precision_recall_fscore_support(
          y_true,
          y_pred,
          beta=beta,
          labels=labels,
          pos_label=pos_label,
          average=average,
          warn_for=("f-score",),
          sample_weight=sample_weight,
          zero_division=zero_division,
      )
      return f
  
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 13 for calling a global function with example usage: fbeta_score(y_true, y_pred) and returns: f