
import inspect
import unittest

from transformers import ConvNextConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
			from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import AutoImageProcessor




class        _SCREAMING_SNAKE_CASE	:



	def __init__(       self		,    lowercase		,    lowercase=13		,    lowercase=32		,    lowercase=3		,    lowercase=4		,    lowercase=[10, 20, 30, 40]		,    lowercase=[2, 2, 3, 2]		,    lowercase=True		,    lowercase=True		,    lowercase=37		,    lowercase="gelu"		,    lowercase=10		,    lowercase=0.0_2		,    lowercase=["stage2", "stage3", "stage4"]		,    lowercase=[2, 3, 4]		,    lowercase=None		,    )							->			Any:
					lowerCamelCase_         =     parent
					lowerCamelCase_         =     batch_size
					lowerCamelCase_         =     image_size
					lowerCamelCase_         =     num_channels
					lowerCamelCase_         =     num_stages
					lowerCamelCase_         =     hidden_sizes
					lowerCamelCase_         =     depths
					lowerCamelCase_         =     is_training
					lowerCamelCase_         =     use_labels
					lowerCamelCase_         =     intermediate_size
					lowerCamelCase_         =     hidden_act
					lowerCamelCase_         =     num_labels
					lowerCamelCase_         =     initializer_range
					lowerCamelCase_         =     out_features
					lowerCamelCase_         =     out_indices
					lowerCamelCase_         =     scope



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Tuple:
					lowerCamelCase_         =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

					lowerCamelCase_         =     None
					if self.use_labels:
									lowerCamelCase_         =     ids_tensor([self.batch_size]		,    self.num_labels					)

					lowerCamelCase_         =     self.get_config()
					return config, pixel_values, labels



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					return ConvNextConfig(
					    num_channels=self.num_channels		,    hidden_sizes=self.hidden_sizes		,    depths=self.depths		,    num_stages=self.num_stages		,    hidden_act=self.hidden_act		,    is_decoder=lowercase		,    initializer_range=self.initializer_range		,    out_features=self.out_features		,    out_indices=self.out_indices		,    num_labels=self.num_labels		,    )



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase					)							->			Tuple:
					lowerCamelCase_         =     ConvNextModel(config=lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase					)
					# expected last hidden states: B, C, H // 32, W // 32
					self.parent.assertEqual(
					    result.last_hidden_state.shape		,    (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)		,    )



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase					)							->			str:
					lowerCamelCase_         =     ConvNextForImageClassification(lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase		,    labels=lowercase					)
					self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.num_labels)					)



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase					)							->			str:
					lowerCamelCase_         =     ConvNextBackbone(config=lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase					)

					# verify hidden states
					self.parent.assertEqual(len(result.feature_maps					)		,    len(config.out_features					)					)
					self.parent.assertListEqual(list(result.feature_maps[0].shape					)		,    [self.batch_size, self.hidden_sizes[1], 4, 4]					)

					# verify channels
					self.parent.assertEqual(len(model.channels					)		,    len(config.out_features					)					)
					self.parent.assertListEqual(model.channels		,    config.hidden_sizes[1:]					)

					# verify backbone works with out_features=None
					lowerCamelCase_         =     None
					lowerCamelCase_         =     ConvNextBackbone(config=lowercase					)
					model.to(lowercase					)
					model.eval()
					lowerCamelCase_         =     model(lowercase					)

					# verify feature maps
					self.parent.assertEqual(len(result.feature_maps					)		,    1					)
					self.parent.assertListEqual(list(result.feature_maps[0].shape					)		,    [self.batch_size, self.hidden_sizes[-1], 1, 1]					)

					# verify channels
					self.parent.assertEqual(len(model.channels					)		,    1					)
					self.parent.assertListEqual(model.channels		,    [config.hidden_sizes[-1]]					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					lowerCamelCase_         =     self.prepare_config_and_inputs()
					lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_         =     config_and_inputs
					lowerCamelCase_         =     {"pixel_values": pixel_values}
					return config, inputs_dict




@require_torch
class        _SCREAMING_SNAKE_CASE	( snake_case_     ,			snake_case_     ,			unittest.TestCase		):
	lowerCAmelCase__   =					(
	    (
	        ConvNextModel,
	        ConvNextForImageClassification,
	        ConvNextBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	lowerCAmelCase__   =					(
	    {'feature-extraction': ConvNextModel, 'image-classification': ConvNextForImageClassification}
	    if is_torch_available()
	    else {}
	)

	lowerCAmelCase__   =					True
	lowerCAmelCase__   =					False
	lowerCAmelCase__   =					False
	lowerCAmelCase__   =					False
	lowerCAmelCase__   =					False



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[int]:
					lowerCamelCase_         =     ConvNextModelTester(self					)
					lowerCamelCase_         =     ConfigTester(self		,    config_class=lowercase		,    has_text_modality=lowercase		,    hidden_size=37					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Union[str, Any]:
					self.create_and_test_config_common_properties()
					self.config_tester.create_and_test_config_to_json_string()
					self.config_tester.create_and_test_config_to_json_file()
					self.config_tester.create_and_test_config_from_and_save_pretrained()
					self.config_tester.create_and_test_config_with_num_labels()
					self.config_tester.check_config_can_be_init_without_params()
					self.config_tester.check_config_arguments_init()



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					return



	@unittest.skip(reason="ConvNext does not use inputs_embeds"					)
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[str]:
					pass



	@unittest.skip(reason="ConvNext does not support input and output embeddings"					)
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					pass



	@unittest.skip(reason="ConvNext does not use feedforward chunking"					)
	def        SCREAMING_SNAKE_CASE_(       self					)							->			Tuple:
					pass



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Union[str, Any]:
					lowerCamelCase_      ,       lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									lowerCamelCase_         =     model_class(lowercase					)
									lowerCamelCase_         =     inspect.signature(model.forward					)
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									lowerCamelCase_         =     [*signature.parameters.keys()]

									lowerCamelCase_         =     ["pixel_values"]
									self.assertListEqual(arg_names[:1]		,    lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Optional[Any]:
					def check_hidden_states_output(lowercase		,    lowercase		,    lowercase					):
									lowerCamelCase_         =     model_class(lowercase					)
									model.to(lowercase					)
									model.eval()

									with torch.no_grad():
													lowerCamelCase_         =     model(**self._prepare_for_class(lowercase		,    lowercase					)					)

									lowerCamelCase_         =     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

									lowerCamelCase_         =     self.model_tester.num_stages
									self.assertEqual(len(lowercase					)		,    expected_num_stages + 1					)

									# ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
									self.assertListEqual(
									    list(hidden_states[0].shape[-2:]					)		,    [self.model_tester.image_size // 4, self.model_tester.image_size // 4]		,    )

					lowerCamelCase_      ,       lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									lowerCamelCase_         =     True
									check_hidden_states_output(lowercase		,    lowercase		,    lowercase					)

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									lowerCamelCase_         =     True

									check_hidden_states_output(lowercase		,    lowercase		,    lowercase					)



	def        SCREAMING_SNAKE_CASE_(       self					)							->			str:
					lowerCamelCase_         =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*lowercase					)



	@slow
	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowerCamelCase_         =     ConvNextModel.from_pretrained(lowercase					)
									self.assertIsNotNone(lowercase					)





def      lowerCamelCase_					(							):
				lowerCamelCase_         =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
				return image




@require_torch
@require_vision
class        _SCREAMING_SNAKE_CASE	( unittest.TestCase		):



	@cached_property
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[str]:
					return AutoImageProcessor.from_pretrained("facebook/convnext-tiny-224"					) if is_vision_available() else None



	@slow
	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					lowerCamelCase_         =     ConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224"					).to(lowercase					)

					lowerCamelCase_         =     self.default_image_processor
					lowerCamelCase_         =     prepare_img()
					lowerCamelCase_         =     image_processor(images=lowercase		,    return_tensors="pt"					).to(lowercase					)

					# forward pass
					with torch.no_grad():
									lowerCamelCase_         =     model(**lowercase					)

					# verify the logits
					lowerCamelCase_         =     torch.Size((1, 1000)					)
					self.assertEqual(outputs.logits.shape		,    lowercase					)

					lowerCamelCase_         =     torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]					).to(lowercase					)

					self.assertTrue(torch.allclose(outputs.logits[0, :3]		,    lowercase		,    atol=1e-4					)					)




@require_torch
class        _SCREAMING_SNAKE_CASE	( unittest.TestCase     ,			snake_case_		):
	lowerCAmelCase__   =					(ConvNextBackbone,) if is_torch_available() else ()
	lowerCAmelCase__   =					ConvNextConfig

	lowerCAmelCase__   =					False



	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[Any]:
					lowerCamelCase_         =     ConvNextModelTester(self					)




import sacrebleu as scb
from packaging import version
from sacrebleu import TER

import datasets


__A							='''\
@inproceedings{snover-etal-2006-study,
    title = "A Study of Translation Edit Rate with Targeted Human Annotation",
    author = "Snover, Matthew  and
      Dorr, Bonnie  and
      Schwartz, Rich  and
      Micciulla, Linnea  and
      Makhoul, John",
    booktitle = "Proceedings of the 7th Conference of the Association for Machine Translation in the Americas: Technical Papers",
    month = aug # " 8-12",
    year = "2006",
    address = "Cambridge, Massachusetts, USA",
    publisher = "Association for Machine Translation in the Americas",
    url = "https://aclanthology.org/2006.amta-papers.25",
    pages = "223--231",
}
@inproceedings{post-2018-call,
    title = "A Call for Clarity in Reporting {BLEU} Scores",
    author = "Post, Matt",
    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",
    month = oct,
    year = "2018",
    address = "Belgium, Brussels",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-6319",
    pages = "186--191",
}
'''

__A							='''\
TER (Translation Edit Rate, also called Translation Error Rate) is a metric to quantify the edit operations that a
hypothesis requires to match a reference translation. We use the implementation that is already present in sacrebleu
(https://github.com/mjpost/sacreBLEU#ter), which in turn is inspired by the TERCOM implementation, which can be found
here: https://github.com/jhclark/tercom.

The implementation here is slightly different from sacrebleu in terms of the required input format. The length of
the references and hypotheses lists need to be the same, so you may need to transpose your references compared to
sacrebleu\'s required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534

See the README.md file at https://github.com/mjpost/sacreBLEU#ter for more information.
'''

__A							='''
Produces TER scores alongside the number of edits and reference length.

Args:
    predictions (list of str): The system stream (a sequence of segments).
    references (list of list of str): A list of one or more reference streams (each a sequence of segments).
    normalized (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.
    ignore_punct (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.
    support_zh_ja_chars (boolean): If `True`, tokenization/normalization supports processing of Chinese characters,
                                    as well as Japanese Kanji, Hiragana, Katakana, and Phonetic Extensions of Katakana.
                                    Only applies if `normalized = True`. Defaults to `False`.
    case_sensitive (boolean): If `False`, makes all predictions and references lowercase to ignore differences in case. Defaults to `False`.

Returns:
    \'score\' (float): TER score (num_edits / sum_ref_lengths * 100)
    \'num_edits\' (int): The cumulative number of edits
    \'ref_length\' (float): The cumulative average reference length

Examples:
    Example 1:
        >>> predictions = ["does this sentence match??",
        ...                     "what about this sentence?",
        ...                     "What did the TER metric user say to the developer?"]
        >>> references = [["does this sentence match", "does this sentence match!?!"],
        ...             ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"],
        ...             ["Your jokes are...", "...TERrible"]]
        >>> ter = datasets.load_metric("ter")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         case_sensitive=True)
        >>> print(results)
        {\'score\': 150.0, \'num_edits\': 15, \'ref_length\': 10.0}

    Example 2:
        >>> predictions = ["does this sentence match??",
        ...                     "what about this sentence?"]
        >>> references = [["does this sentence match", "does this sentence match!?!"],
        ...             ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"]]
        >>> ter = datasets.load_metric("ter")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         case_sensitive=True)
        >>> print(results)
        {\'score\': 62.5, \'num_edits\': 5, \'ref_length\': 8.0}

    Example 3:
        >>> predictions = ["does this sentence match??",
        ...                     "what about this sentence?"]
        >>> references = [["does this sentence match", "does this sentence match!?!"],
        ...             ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"]]
        >>> ter = datasets.load_metric("ter")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         normalized=True,
        ...                         case_sensitive=True)
        >>> print(results)
        {\'score\': 57.14285714285714, \'num_edits\': 6, \'ref_length\': 10.5}

    Example 4:
        >>> predictions = ["does this sentence match??",
        ...                     "what about this sentence?"]
        >>> references = [["does this sentence match", "does this sentence match!?!"],
        ...             ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"]]
        >>> ter = datasets.load_metric("ter")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         ignore_punct=True,
        ...                         case_sensitive=False)
        >>> print(results)
        {\'score\': 0.0, \'num_edits\': 0, \'ref_length\': 8.0}

    Example 5:
        >>> predictions = ["does this sentence match??",
        ...                    "what about this sentence?",
        ...                    "What did the TER metric user say to the developer?"]
        >>> references = [["does this sentence match", "does this sentence match!?!"],
        ...             ["wHaT aBoUt ThIs SeNtEnCe?", "wHaT aBoUt ThIs SeNtEnCe?"],
        ...             ["Your jokes are...", "...TERrible"]]
        >>> ter = datasets.load_metric("ter")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         ignore_punct=True,
        ...                         case_sensitive=False)
        >>> print(results)
        {\'score\': 100.0, \'num_edits\': 10, \'ref_length\': 10.0}
'''




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



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					if version.parse(scb.__version__					) < version.parse("1.4.12"					):
									raise ImportWarning(
									    "To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn't match this condition.\n"
									    "You can install it with `pip install \"sacrebleu>=1.4.12\"`."					)
					return datasets.MetricInfo(
					    description=_DESCRIPTION		,    citation=_CITATION		,    homepage="http://www.cs.umd.edu/~snover/tercom/"		,    inputs_description=_KWARGS_DESCRIPTION		,    features=datasets.Features(
					        {
					            "predictions": datasets.Value("string"		,    id="sequence"					),
					            "references": datasets.Sequence(datasets.Value("string"		,    id="sequence"					)		,    id="references"					),
					        }					)		,    codebase_urls=["https://github.com/mjpost/sacreBLEU#ter"]		,    reference_urls=[
					        "https://github.com/jhclark/tercom",
					    ]		,    )



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase		,    lowercase		,    lowercase = False		,    lowercase = False		,    lowercase = False		,    lowercase = False		,    )							->			Tuple:
					lowerCamelCase_         =     len(references[0]					)
					if any(len(lowercase					) != references_per_prediction for refs in references					):
									raise ValueError("Sacrebleu requires the same number of references for each prediction"					)
					lowerCamelCase_         =     [[refs[i] for refs in references] for i in range(lowercase					)]

					lowerCamelCase_         =     TER(
					    normalized=lowercase		,    no_punct=lowercase		,    asian_support=lowercase		,    case_sensitive=lowercase		,    )
					lowerCamelCase_         =     sb_ter.corpus_score(lowercase		,    lowercase					)

					return {"score": output.score, "num_edits": output.num_edits, "ref_length": output.ref_length}


