class_docstr: A utility class for scoring chunk parsers.  ``ChunkScore`` can
  evaluate a chunk parser's output, based on a number of statistics
  (precision, recall, f-measure, misssed chunks, incorrect chunks).
  It can also combine the scores from the parsing of multiple texts;
  this makes it significantly easier to evaluate a chunk parser that
  operates one sentence at a time.
  
  Texts are evaluated with the ``score`` method.  The results of
  evaluation can be accessed via a number of accessor methods, such
  as ``precision`` and ``f_measure``.  A typical use of the
  ``ChunkScore`` class is::
  
      >>> chunkscore = ChunkScore()           # doctest: +SKIP
      >>> for correct in correct_sentences:   # doctest: +SKIP
      ...     guess = chunkparser.parse(correct.leaves())   # doctest: +SKIP
      ...     chunkscore.score(correct, guess)              # doctest: +SKIP
      >>> print('F Measure:', chunkscore.f_measure())       # doctest: +SKIP
      F Measure: 0.823
  
  :ivar kwargs: Keyword arguments:
  
      - max_tp_examples: The maximum number actual examples of true
        positives to record.  This affects the ``correct`` member
        function: ``correct`` will not return more than this number
        of true positive examples.  This does *not* affect any of
        the numerical metrics (precision, recall, or f-measure)
  
      - max_fp_examples: The maximum number actual examples of false
        positives to record.  This affects the ``incorrect`` member
        function and the ``guessed`` member function: ``incorrect``
        will not return more than this number of examples, and
        ``guessed`` will not return more than this number of true
        positive examples.  This does *not* affect any of the
        numerical metrics (precision, recall, or f-measure)
  
      - max_fn_examples: The maximum number actual examples of false
        negatives to record.  This affects the ``missed`` member
        function and the ``correct`` member function: ``missed``
        will not return more than this number of examples, and
        ``correct`` will not return more than this number of true
        negative examples.  This does *not* affect any of the
        numerical metrics (precision, recall, or f-measure)
  
      - chunk_label: A regular expression indicating which chunks
        should be compared.  Defaults to ``'.*'`` (i.e., all chunks).
  
  :type _tp: list(Token)
  :ivar _tp: List of true positives
  :type _fp: list(Token)
  :ivar _fp: List of false positives
  :type _fn: list(Token)
  :ivar _fn: List of false negatives
  
  :type _tp_num: int
  :ivar _tp_num: Number of true positives
  :type _fp_num: int
  :ivar _fp_num: Number of false positives
  :type _fn_num: int
  :ivar _fn_num: Number of false negatives.
docstr: Return the overall tag-based accuracy for all text that have
  been scored by this ``ChunkScore``, using the IOB (conll2000)
  tag encoding.
  
  :rtype: float
docstr_tok: ["Return","the","overall","tag-based","accuracy","for","all","text","that","have","been","scored","by","this","``","ChunkScore","``",",","using","the","IOB","(","conll2000",")","tag","encoding",".",":","rtype",":","float"]
code: def accuracy(self):
      """
      Return the overall tag-based accuracy for all text that have
      been scored by this ``ChunkScore``, using the IOB (conll2000)
      tag encoding.
  
      :rtype: float
      """
      if self._tags_total == 0:
          return 1
      return self._tags_correct / self._tags_total
  
imports: import re
  from nltk.metrics import accuracy
  from nltk.tag.mapping import map_tag
  from nltk.tag.util import str2tuple
  from nltk.tree import Tree
label_desc: Use image node_id 4 for calling the ChunkScore obj's underlying member method code with example usage: obj.accuracy() and returns: unknown, int