




'''simple docstring'''

import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image

		from transformers import DeiTImageProcessor





class __magic_name__(						unittest.TestCase      ):






						def __init__(   self						:						str					,   __UpperCamelCase						:						List[str]					,   __UpperCamelCase						:						Tuple=7					,   __UpperCamelCase						:						str=3					,   __UpperCamelCase						:						Any=1_8					,   __UpperCamelCase						:						Any=3_0					,   __UpperCamelCase						:						List[str]=4_0_0					,   __UpperCamelCase						:						str=True					,   __UpperCamelCase						:						Any=None					,   __UpperCamelCase						:						Any=True					,   __UpperCamelCase						:						str=None					,   __UpperCamelCase						:						int=True					,   __UpperCamelCase						:						str=[0.5, 0.5, 0.5]					,   __UpperCamelCase						:						int=[0.5, 0.5, 0.5]					,   ):



									'''simple docstring'''






									snake_case__          =						size if size is not None else {"""height""": 2_0, """width""": 2_0}
									snake_case__          =						crop_size if crop_size is not None else {"""height""": 1_8, """width""": 1_8}

									snake_case__          =						parent
									snake_case__          =						batch_size
									snake_case__          =						num_channels
									snake_case__          =						image_size
									snake_case__          =						min_resolution
									snake_case__          =						max_resolution
									snake_case__          =						do_resize
									snake_case__          =						size
									snake_case__          =						do_center_crop
									snake_case__          =						crop_size
									snake_case__          =						do_normalize
									snake_case__          =						image_mean
									snake_case__          =						image_std







						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									return {
									    "do_resize": self.do_resize,
									    "size": self.size,
									    "do_center_crop": self.do_center_crop,
									    "crop_size": self.crop_size,
									    "do_normalize": self.do_normalize,
									    "image_mean": self.image_mean,
									    "image_std": self.image_std,
									}







@require_torch
@require_vision
class __magic_name__(						__lowerCAmelCase    ,		unittest.TestCase      ):
						UpperCAmelCase_		:					Union[str, Any]    =  DeiTImageProcessor if is_vision_available() else None
						UpperCAmelCase_		:					Any    =  True






						def       __lowerCAmelCase(   self						:						str       ):



									'''simple docstring'''






									snake_case__          =						DeiTImageProcessingTester(self       )






						@property
						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									return self.image_processor_tester.prepare_image_processor_dict()






						def       __lowerCAmelCase(   self						:						Optional[int]       ):



									'''simple docstring'''






									snake_case__          =						self.image_processing_class(**self.image_processor_dict       )
									self.assertTrue(hasattr(__UpperCamelCase					,   """do_resize"""       )       )
									self.assertTrue(hasattr(__UpperCamelCase					,   """size"""       )       )
									self.assertTrue(hasattr(__UpperCamelCase					,   """do_center_crop"""       )       )
									self.assertTrue(hasattr(__UpperCamelCase					,   """center_crop"""       )       )
									self.assertTrue(hasattr(__UpperCamelCase					,   """do_normalize"""       )       )
									self.assertTrue(hasattr(__UpperCamelCase					,   """image_mean"""       )       )
									self.assertTrue(hasattr(__UpperCamelCase					,   """image_std"""       )       )






						def       __lowerCAmelCase(   self						:						List[str]       ):



									'''simple docstring'''






									snake_case__          =						self.image_processing_class.from_dict(self.image_processor_dict       )
									self.assertEqual(image_processor.size					,   {"""height""": 2_0, """width""": 2_0}       )
									self.assertEqual(image_processor.crop_size					,   {"""height""": 1_8, """width""": 1_8}       )

									snake_case__          =						self.image_processing_class.from_dict(self.image_processor_dict					,   size=4_2					,   crop_size=8_4       )
									self.assertEqual(image_processor.size					,   {"""height""": 4_2, """width""": 4_2}       )
									self.assertEqual(image_processor.crop_size					,   {"""height""": 8_4, """width""": 8_4}       )






						def       __lowerCAmelCase(   self						:						Union[str, Any]       ):



									'''simple docstring'''






									pass






						def       __lowerCAmelCase(   self						:						Union[str, Any]       ):



									'''simple docstring'''






									snake_case__          =						self.image_processing_class(**self.image_processor_dict       )
									# create random PIL images
									snake_case__          =						prepare_image_inputs(self.image_processor_tester					,   equal_resolution=__UpperCamelCase       )
									for image in image_inputs:
												self.assertIsInstance(__UpperCamelCase					,   Image.Image       )

									# Test not batched input
									snake_case__          =						image_processing(image_inputs[0]					,   return_tensors="""pt"""       ).pixel_values
									self.assertEqual(
									    encoded_images.shape					,   (
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )					,   )

									# Test batched
									snake_case__          =						image_processing(__UpperCamelCase					,   return_tensors="""pt"""       ).pixel_values
									self.assertEqual(
									    encoded_images.shape					,   (
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )					,   )






						def       __lowerCAmelCase(   self						:						Union[str, Any]       ):



									'''simple docstring'''






									snake_case__          =						self.image_processing_class(**self.image_processor_dict       )
									# create random numpy tensors
									snake_case__          =						prepare_image_inputs(self.image_processor_tester					,   equal_resolution=__UpperCamelCase					,   numpify=__UpperCamelCase       )
									for image in image_inputs:
												self.assertIsInstance(__UpperCamelCase					,   np.ndarray       )

									# Test not batched input
									snake_case__          =						image_processing(image_inputs[0]					,   return_tensors="""pt"""       ).pixel_values
									self.assertEqual(
									    encoded_images.shape					,   (
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )					,   )

									# Test batched
									snake_case__          =						image_processing(__UpperCamelCase					,   return_tensors="""pt"""       ).pixel_values
									self.assertEqual(
									    encoded_images.shape					,   (
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )					,   )







						def       __lowerCAmelCase(   self						:						int       ):



									'''simple docstring'''






									snake_case__          =						self.image_processing_class(**self.image_processor_dict       )
									# create random PyTorch tensors
									snake_case__          =						prepare_image_inputs(self.image_processor_tester					,   equal_resolution=__UpperCamelCase					,   torchify=__UpperCamelCase       )
									for image in image_inputs:
												self.assertIsInstance(__UpperCamelCase					,   torch.Tensor       )

									# Test not batched input
									snake_case__          =						image_processing(image_inputs[0]					,   return_tensors="""pt"""       ).pixel_values
									self.assertEqual(
									    encoded_images.shape					,   (
									        1,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )					,   )

									# Test batched
									snake_case__          =						image_processing(__UpperCamelCase					,   return_tensors="""pt"""       ).pixel_values
									self.assertEqual(
									    encoded_images.shape					,   (
									        self.image_processor_tester.batch_size,
									        self.image_processor_tester.num_channels,
									        self.image_processor_tester.crop_size["""height"""],
									        self.image_processor_tester.crop_size["""width"""],
									    )					,   )







import importlib
from typing import List, Optional, Union

from seqeval.metrics import accuracy_score, classification_report

import datasets


__snake_case     :     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},
}
"""

__snake_case     :     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.
"""

__snake_case     :     Optional[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      __SCREAMING_SNAKE_CASE       ( datasets.Metric):






						def    UpperCamelCase__   (						self ):






												"""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  ,    _UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase = False  ,    _UpperCamelCase = None  ,    _UpperCamelCase = None  ,    _UpperCamelCase = None  ,    _UpperCamelCase = "warn"  ,    ):






												"""simple docstring"""
												if scheme is not None:
																		try:
																								lowerCAmelCase__         =    importlib.import_module('seqeval.scheme' )
																								lowerCAmelCase__         =    getattr(_UpperCamelCase  ,    _UpperCamelCase )
																		except AttributeError:
																								raise ValueError(F"Scheme should be one of [IOB1, IOB2, IOE1, IOE2, IOBES, BILOU], got {scheme}" )
												lowerCAmelCase__         =    classification_report(
												    y_true=_UpperCamelCase  ,    y_pred=_UpperCamelCase  ,    suffix=_UpperCamelCase  ,    output_dict=_UpperCamelCase  ,    scheme=_UpperCamelCase  ,    mode=_UpperCamelCase  ,    sample_weight=_UpperCamelCase  ,    zero_division=_UpperCamelCase  ,    )
												report.pop('macro avg' )
												report.pop('weighted avg' )
												lowerCAmelCase__         =    report.pop('micro avg' )

												lowerCAmelCase__         =    {
												    type_name: {
												        'precision': score['precision'],
												        'recall': score['recall'],
												        'f1': score['f1-score'],
												        'number': score['support'],
												    }
												    for type_name, score in report.items()
												}
												lowerCAmelCase__         =    overall_score['precision']
												lowerCAmelCase__         =    overall_score['recall']
												lowerCAmelCase__         =    overall_score['f1-score']
												lowerCAmelCase__         =    accuracy_score(y_true=_UpperCamelCase  ,    y_pred=_UpperCamelCase )

												return scores





