






"""simple docstring"""





from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_clip import CLIPTokenizer


UpperCamelCase_						:					str      				=			logging.get_logger(__name__)

UpperCamelCase_						:					Optional[int]      				=			{"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""}

UpperCamelCase_						:					str      				=			{
    """vocab_file""": {
        """openai/clip-vit-base-patch32""": """https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/vocab.json""",
    },
    """merges_file""": {
        """openai/clip-vit-base-patch32""": """https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/merges.txt""",
    },
    """tokenizer_file""": {
        """openai/clip-vit-base-patch32""": (
            """https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/tokenizer.json"""
        ),
    },
}

UpperCamelCase_						:					str      				=			{
    """openai/clip-vit-base-patch32""": 77,
}


class   _lowercase			(  lowerCAmelCase    ):
      _a :  Dict										= VOCAB_FILES_NAMES
      _a :  str										= PRETRAINED_VOCAB_FILES_MAP
      _a :  List[Any]										= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      _a :  str										= ['''input_ids''', '''attention_mask''']
      _a :  Optional[Any]										= CLIPTokenizer


      def __init__(     self					:						Dict				, a					:						Optional[Any]=None				, a					:						List[Any]=None				, a					:						Any=None				, a					:						Dict="<|endoftext|>"				, a					:						Tuple="<|startoftext|>"				, a					:						List[Any]="<|endoftext|>"				, a					:						Tuple="<|endoftext|>"				, **a					:						Dict				, ):





            """simple docstring"""







            super().__init__(
                a				, a				, tokenizer_file=a				, unk_token=a				, bos_token=a				, eos_token=a				, pad_token=a				, **a				, )

            if not isinstance(self.backend_tokenizer.pre_tokenizer				, pre_tokenizers.Sequence    ):
                  raise ValueError(
                      '''The `backend_tokenizer` provided does not match the expected format. The CLIP tokenizer has been'''
                      ''' heavily modified from transformers version 4.17.0. You need to convert the tokenizer you are using'''
                      ''' to be compatible with this version.The easiest way to do so is'''
                      ''' `CLIPTokenizerFast.from_pretrained("path_to_local_folder_or_hub_repo, from_slow=True)`. If you want'''
                      ''' to use your existing tokenizer, you will have to revert to a version prior to 4.17.0 of'''
                      ''' transformers.'''    )

            self._wrap_decode_method_backend_tokenizer()


      def _UpperCamelCase    (     self					:						Dict    ):





            """simple docstring"""







            __snake_case   :     str	      =self.backend_tokenizer.decode

            def new_decode_method(*a					:						Optional[int]				, **a					:						str    ):
                  __snake_case   :     Optional[int]	      =orig_decode_method(*a				, **a    )
                  __snake_case   :     Optional[Any]	      =text.replace(self.backend_tokenizer.model.end_of_word_suffix				, ''' '''    ).strip()
                  return text

            __snake_case   :     Union[str, Any]	      =new_decode_method


      def _UpperCamelCase    (     self					:						Union[str, Any]				, a					:						List[int]				, a					:						Optional[List[int]] = None    ):





            """simple docstring"""







            __snake_case   :     Tuple	      =[self.bos_token_id]
            __snake_case   :     Optional[Any]	      =[self.eos_token_id]

            if token_ids_a is None:
                  return bos_token + token_ids_a + eos_token
            return bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token


      def _UpperCamelCase    (     self					:						List[str]				, a					:						List[int]				, a					:						Optional[List[int]] = None    ):





            """simple docstring"""







            __snake_case   :     Union[str, Any]	      =[self.bos_token_id]
            __snake_case   :     Any	      =[self.eos_token_id]

            if token_ids_a is None:
                  return len(bos_token + token_ids_a + eos_token    ) * [0]
            return len(bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token    ) * [0]







      def _UpperCamelCase    (     self					:						Any				, a					:						str				, a					:						Optional[str] = None    ):





            """simple docstring"""







            __snake_case   :     Tuple	      =self._tokenizer.model.save(a				, name=a    )
            return tuple(a    )










"""simple docstring"""





import importlib
from typing import List, Optional, Union

from seqeval.metrics import accuracy_score, classification_report

import datasets


UpperCamelCase_						:					Optional[int]      				=			"""\
@inproceedings{ramshaw-marcus-1995-text,
    title = \"Text Chunking using Transformation-Based Learning\",
    author = \"Ramshaw, Lance  and
      Marcus, Mitch\",
    booktitle = \"Third Workshop on Very Large Corpora\",
    year = \"1995\",
    url = \"https://www.aclweb.org/anthology/W95-0107\",
}
@misc{seqeval,
  title={{seqeval}: A Python framework for sequence labeling evaluation},
  url={https://github.com/chakki-works/seqeval},
  note={Software available from https://github.com/chakki-works/seqeval},
  author={Hiroki Nakayama},
  year={2018},
}
"""

UpperCamelCase_						:					Any      				=			"""\
seqeval is a Python framework for sequence labeling evaluation.
seqeval can evaluate the performance of chunking tasks such as named-entity recognition, part-of-speech tagging, semantic role labeling and so on.

This is well-tested by using the Perl script conlleval, which can be used for
measuring the performance of a system that has processed the CoNLL-2000 shared task data.

seqeval supports following formats:
IOB1
IOB2
IOE1
IOE2
IOBES

See the [README.md] file at https://github.com/chakki-works/seqeval for more information.
"""

UpperCamelCase_						:					int      				=			"""
Produces labelling scores along with its sufficient statistics
from a source against one or more references.

Args:
    predictions: List of List of predicted labels (Estimated targets as returned by a tagger)
    references: List of List of reference labels (Ground truth (correct) target values)
    suffix: True if the IOB prefix is after type, False otherwise. default: False
    scheme: Specify target tagging scheme. Should be one of [\"IOB1\", \"IOB2\", \"IOE1\", \"IOE2\", \"IOBES\", \"BILOU\"].
        default: None
    mode: Whether to count correct entity labels with incorrect I/B tags as true positives or not.
        If you want to only count exact matches, pass mode=\"strict\". default: None.
    sample_weight: Array-like of shape (n_samples,), weights for individual samples. default: None
    zero_division: Which value to substitute as a metric value when encountering zero division. Should be on of 0, 1,
        \"warn\". \"warn\" acts as 0, but the warning is raised.

Returns:
    'scores': dict. Summary of the scores for overall and per type
        Overall:
            'accuracy': accuracy,
            'precision': precision,
            'recall': recall,
            'f1': F1 score, also known as balanced F-score or F-measure,
        Per type:
            'precision': precision,
            'recall': recall,
            'f1': F1 score, also known as balanced F-score or F-measure
Examples:

    >>> predictions = [['O', 'O', 'B-MISC', 'I-MISC', 'I-MISC', 'I-MISC', 'O'], ['B-PER', 'I-PER', 'O']]
    >>> references = [['O', 'O', 'O', 'B-MISC', 'I-MISC', 'I-MISC', 'O'], ['B-PER', 'I-PER', 'O']]
    >>> seqeval = datasets.load_metric(\"seqeval\")
    >>> results = seqeval.compute(predictions=predictions, references=references)
    >>> print(list(results.keys()))
    ['MISC', 'PER', 'overall_precision', 'overall_recall', 'overall_f1', 'overall_accuracy']
    >>> print(results[\"overall_f1\"])
    0.5
    >>> print(results[\"PER\"][\"f1\"])
    1.0
"""


@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION		,	_KWARGS_DESCRIPTION    )
class   _lowercase			(  datasets.Metric    ):


      def _UpperCamelCase    (     self					:						int    ):





            """simple docstring"""







            return datasets.MetricInfo(
                description=_DESCRIPTION				, citation=_CITATION				, homepage='''https://github.com/chakki-works/seqeval'''				, inputs_description=_KWARGS_DESCRIPTION				, features=datasets.Features(
                    {
                        '''predictions''': datasets.Sequence(datasets.Value('''string'''				, id='''label'''    )				, id='''sequence'''    ),
                        '''references''': datasets.Sequence(datasets.Value('''string'''				, id='''label'''    )				, id='''sequence'''    ),
                    }    )				, codebase_urls=['''https://github.com/chakki-works/seqeval''']				, reference_urls=['''https://github.com/chakki-works/seqeval''']				, )







      def _UpperCamelCase    (     self					:						List[Any]				, a					:						List[str]				, a					:						Optional[Any]				, a					:						bool = False				, a					:						Optional[str] = None				, a					:						Optional[str] = None				, a					:						Optional[List[int]] = None				, a					:						Union[str, int] = "warn"				, ):





            """simple docstring"""







            if scheme is not None:
                  try:
                        __snake_case   :     List[str]	      =importlib.import_module('''seqeval.scheme'''    )
                        __snake_case   :     int	      =getattr(a				, a    )
                  except AttributeError:
                        raise ValueError(f'''Scheme should be one of [IOB1, IOB2, IOE1, IOE2, IOBES, BILOU], got {scheme}'''    )
            __snake_case   :     Optional[Any]	      =classification_report(
                y_true=a				, y_pred=a				, suffix=a				, output_dict=a				, scheme=a				, mode=a				, sample_weight=a				, zero_division=a				, )
            report.pop('''macro avg'''    )
            report.pop('''weighted avg'''    )
            __snake_case   :     Union[str, Any]	      =report.pop('''micro avg'''    )

            __snake_case   :     str	      ={
                type_name: {
                    '''precision''': score['''precision'''],
                    '''recall''': score['''recall'''],
                    '''f1''': score['''f1-score'''],
                    '''number''': score['''support'''],
                }
                for type_name, score in report.items()
            }
            __snake_case   :     str	      =overall_score['''precision''']
            __snake_case   :     int	      =overall_score['''recall''']
            __snake_case   :     str	      =overall_score['''f1-score''']
            __snake_case   :     Union[str, Any]	      =accuracy_score(y_true=a				, y_pred=a    )

            return scores


