class_docstr: Probabilistic Classifier Chains.
  
  The Probabilistic Classifier Chains (PCC) [^1] is a Bayes-optimal method
  based on the Classifier Chains (CC).
  
  Consider the concept of chaining classifiers as searching a path in a
  binary tree whose leaf nodes are associated with a label $y \in Y$. While
  CC searches only a single path in the aforementioned binary tree, PCC looks
  at each of the $2^l$ paths, where $l$ is the number of labels. This limits
  the applicability of the method to data sets with a small to moderate
  number of labels. The authors recommend no more than about 15 labels for
  real-world applications.
  
  Parameters
  ----------
  model
  
  Examples
  --------
  
  >>> from river import linear_model
  >>> from river import metrics
  >>> from river import multioutput
  >>> from river.datasets import synth
  
  >>> dataset = synth.Logical(seed=42, n_tiles=100)
  
  >>> model = multioutput.ProbabilisticClassifierChain(
  ...     model=linear_model.LogisticRegression()
  ... )
  
  >>> metric = metrics.multioutput.MicroAverage(metrics.Jaccard())
  
  >>> for x, y in dataset:
  ...    y_pred = model.predict_one(x)
  ...    y_pred = {k: y_pred.get(k, 0) for k in y}
  ...    metric.update(y, y_pred)
  ...    model.learn_one(x, y)
  
  >>> metric
  MicroAverage(Jaccard): 51.84%
  
  References
  ----------
  [^1]: Cheng, W., Hüllermeier, E., & Dembczynski, K. J. (2010).
        Bayes optimal multilabel classification via probabilistic classifier
        chains. In Proceedings of the 27th international conference on
        machine learning (ICML-10) (pp. 279-286).
code: def predict_one(self, x, **kwargs):
      y_pred = {}
  
      if not isinstance(self.order, list):
          return y_pred
  
      max_payoff = 0.0
      n_labels = len(self.order)
      # for each and every possible label combination
      for label in range(2**n_labels):
          # put together a binary label vector
          y_gen = {
              i: int(v)
              for i, v in zip(
                  self.order, list(bin(label)[2:].zfill(n_labels))
              )
          }
          # ... and gauge a probability for it (given x)
          payoff = self._payoff(x=x, y=y_gen, **kwargs)
          # if it performs well, keep it, and record the max
          if payoff > max_payoff:
              y_pred = copy.copy(y_gen)
              max_payoff = payoff
      return y_pred
  
imports: from __future__ import annotations
  import collections
  import copy
  import functools
  import random
  from river import base, linear_model
  from river.utils.math import minkowski_distance, prod
label_desc: Use image node_id 2 for calling the ProbabilisticClassifierChain obj's underlying member method code with example usage: obj.predict_one(x) and returns: y_pred, y_pred