class_docstr: Compute different types of Cohen's Kappa: Non-Wieghted, Linear, Quadratic.
  Accumulating predictions and the ground-truth during an epoch and applying
  `sklearn.metrics.cohen_kappa_score <https://scikit-learn.org/stable/modules/
  generated/sklearn.metrics.cohen_kappa_score.html>`_ .
  
  Args:
      output_transform: a callable that is used to transform the
          :class:`~ignite.engine.engine.Engine`'s ``process_function``'s output into the
          form expected by the metric. This can be useful if, for example, you have a multi-output model and
          you want to compute the metric with respect to one of the outputs.
      weights: a string is used to define the type of Cohen's Kappa whether Non-Weighted or Linear
          or Quadratic. Default, None.
      check_compute_fn: Default False. If True, `cohen_kappa_score
          <https://scikit-learn.org/stable/modules/generated/sklearn.metrics.cohen_kappa_score.html>`_
          is run on the first batch of data to ensure there are
          no issues. User will be warned in case there are any issues computing the function.
      device: optional device specification for internal storage.
  
  Examples:
      To use with ``Engine`` and ``process_function``, simply attach the metric instance to the engine.
      The output of the engine's ``process_function`` needs to be in the format of
      ``(y_pred, y)`` or ``{'y_pred': y_pred, 'y': y, ...}``. If not, ``output_tranform`` can be added
      to the metric to transform the output into the form expected by the metric.
  
      .. include:: defaults.rst
          :start-after: :orphan:
  
      .. testcode::
  
          metric = CohenKappa()
          metric.attach(default_evaluator, 'ck')
          y_true = torch.tensor([2, 0, 2, 2, 0, 1])
          y_pred = torch.tensor([0, 0, 2, 2, 0, 2])
          state = default_evaluator.run([[y_pred, y_true]])
          print(state.metrics['ck'])
  
      .. testoutput::
  
          0.4285...
docstr: Return a function computing Cohen Kappa from scikit-learn.
docstr_tok: ["Return","a","function","computing","Cohen","Kappa","from","scikit-learn","."]
code: def get_cohen_kappa_fn(
      self,
  ) -> Callable[[torch.Tensor, torch.Tensor], float]:
      """Return a function computing Cohen Kappa from scikit-learn."""
      from sklearn.metrics import cohen_kappa_score
  
      def wrapper(
          y_targets: torch.Tensor, y_preds: torch.Tensor
      ) -> float:
          y_true = y_targets.cpu().numpy()
          y_pred = y_preds.cpu().numpy()
          return cohen_kappa_score(y_true, y_pred, weights=self.weights)
  
      return wrapper
  
imports: from typing import Callable, Optional, Union
  import torch
  from ignite.metrics import EpochMetric
label_desc: Use image node_id 2 for calling the CohenKappa obj's underlying member method code with example usage: obj.get_cohen_kappa_fn() and returns: wrapper, cohen_kappa_score