



'''simple docstring'''




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

import datasets


a     :    str      						=					"""\
@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     :    Optional[int]      						=					"""\
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     :    Optional[Any]      						=					"""
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     UpperCamelCase_				(							datasets.Metric    ):





	def 				_lowercase(						self					)    ->    Any:
								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 				_lowercase(						self	,	A	,	A	,	A = False	,	A = False	,	A = False	,	A = False	,	)    ->    Tuple:
								UpperCAmelCase  :	Optional[int]							  =	len(references[0]					)
								if any(len(A					) != references_per_prediction for refs in references					):
															raise ValueError("""Sacrebleu requires the same number of references for each prediction"""					)
								UpperCAmelCase  :	Union[str, Any]							  =	[[refs[i] for refs in references] for i in range(A					)]

								UpperCAmelCase  :	Optional[int]							  =	TER(
								    normalized=A	,	no_punct=A	,	asian_support=A	,	case_sensitive=A	,	)
								UpperCAmelCase  :	List[str]							  =	sb_ter.corpus_score(A	,	A					)

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






'''simple docstring'''




import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
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_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 ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
							from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor

class     UpperCamelCase_				:





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





	def 				_lowercase(						self					)    ->    Union[str, Any]:
								UpperCAmelCase  :	Tuple							  =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

								UpperCAmelCase  :	List[Any]							  =	None
								if self.use_labels:
															UpperCAmelCase  :	Dict							  =	ids_tensor([self.batch_size]	,	self.num_labels					)

								UpperCAmelCase  :	List[str]							  =	self.get_config()

								return config, pixel_values, labels





	def 				_lowercase(						self					)    ->    Optional[Any]:
								return ConvNextVaConfig(
								    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=A	,	initializer_range=self.initializer_range	,	out_features=self.out_features	,	out_indices=self.out_indices	,	num_labels=self.num_labels	,	)





	def 				_lowercase(						self	,	A	,	A	,	A					)    ->    Optional[Any]:
								UpperCAmelCase  :	int							  =	ConvNextVaModel(config=A					)
								model.to(A					)
								model.eval()
								UpperCAmelCase  :	List[Any]							  =	model(A					)
								# 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 				_lowercase(						self	,	A	,	A	,	A					)    ->    Any:
								UpperCAmelCase  :	List[str]							  =	ConvNextVaForImageClassification(A					)
								model.to(A					)
								model.eval()
								UpperCAmelCase  :	int							  =	model(A	,	labels=A					)
								self.parent.assertEqual(result.logits.shape	,	(self.batch_size, self.num_labels)					)





	def 				_lowercase(						self	,	A	,	A	,	A					)    ->    Any:
								UpperCAmelCase  :	Optional[Any]							  =	ConvNextVaBackbone(config=A					)
								model.to(A					)
								model.eval()
								UpperCAmelCase  :	Any							  =	model(A					)

								# 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
								UpperCAmelCase  :	Any							  =	None
								UpperCAmelCase  :	Optional[int]							  =	ConvNextVaBackbone(config=A					)
								model.to(A					)
								model.eval()
								UpperCAmelCase  :	int							  =	model(A					)

								# 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 				_lowercase(						self					)    ->    List[str]:
								UpperCAmelCase  :	Dict							  =	self.prepare_config_and_inputs()
								UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  :	List[Any]							  =	config_and_inputs
								UpperCAmelCase  :	str							  =	{"""pixel_values""": pixel_values}
								return config, inputs_dict






	def 				_lowercase(						self					)    ->    List[Any]:
								UpperCAmelCase  :	List[str]							  =	self.prepare_config_and_inputs()
								UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  :	Optional[Any]							  =	config_and_inputs
								UpperCAmelCase  :	List[str]							  =	{"""pixel_values""": pixel_values, """labels""": labels}
								return config, inputs_dict




@require_torch
class     UpperCamelCase_				(							__magic_name__   ,  __magic_name__   ,  unittest.TestCase    ):
	lowercase    =				(
	    (
	        ConvNextVaModel,
	        ConvNextVaForImageClassification,
	        ConvNextVaBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	lowercase    =				(
	    {'feature-extraction': ConvNextVaModel, 'image-classification': ConvNextVaForImageClassification}
	    if is_torch_available()
	    else {}
	)

	lowercase    =				False
	lowercase    =				False
	lowercase    =				False
	lowercase    =				False
	lowercase    =				False





	def 				_lowercase(						self					)    ->    Optional[int]:
								UpperCAmelCase  :	Dict							  =	ConvNextVaModelTester(self					)
								UpperCAmelCase  :	List[str]							  =	ConfigTester(self	,	config_class=A	,	has_text_modality=A	,	hidden_size=37					)





	def 				_lowercase(						self					)    ->    int:
								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 				_lowercase(						self					)    ->    List[str]:
								return





	@unittest.skip(reason="""ConvNextV2 does not use inputs_embeds"""					)
	def 				_lowercase(						self					)    ->    Dict:
								pass





	@unittest.skip(reason="""ConvNextV2 does not support input and output embeddings"""					)
	def 				_lowercase(						self					)    ->    Any:
								pass





	@unittest.skip(reason="""ConvNextV2 does not use feedforward chunking"""					)
	def 				_lowercase(						self					)    ->    int:
								pass





	def 				_lowercase(						self					)    ->    Dict:
								if not self.model_tester.is_training:
															return

								for model_class in self.all_model_classes:
															UpperCAmelCase  ,  UpperCAmelCase  :	Optional[Any]							  =	self.model_tester.prepare_config_and_inputs_with_labels()
															UpperCAmelCase  :	Optional[int]							  =	True

															if model_class.__name__ in [
															    *get_values(A					),
															    *get_values(A					),
															]:
																						continue

															UpperCAmelCase  :	Any							  =	model_class(A					)
															model.to(A					)
															model.train()
															UpperCAmelCase  :	List[str]							  =	self._prepare_for_class(A	,	A	,	return_labels=A					)
															UpperCAmelCase  :	List[str]							  =	model(**A					).loss
															loss.backward()





	def 				_lowercase(						self					)    ->    Tuple:
								if not self.model_tester.is_training:
															return

								for model_class in self.all_model_classes:
															UpperCAmelCase  ,  UpperCAmelCase  :	Any							  =	self.model_tester.prepare_config_and_inputs_with_labels()
															UpperCAmelCase  :	List[str]							  =	False
															UpperCAmelCase  :	int							  =	True

															if (
															    model_class.__name__
															    in [*get_values(A					), *get_values(A					)]
															    or not model_class.supports_gradient_checkpointing
															):
																						continue

															UpperCAmelCase  :	Dict							  =	model_class(A					)
															model.to(A					)
															model.gradient_checkpointing_enable()
															model.train()
															UpperCAmelCase  :	Any							  =	self._prepare_for_class(A	,	A	,	return_labels=A					)
															UpperCAmelCase  :	Any							  =	model(**A					).loss
															loss.backward()





	def 				_lowercase(						self					)    ->    Tuple:
								UpperCAmelCase  ,  UpperCAmelCase  :	List[Any]							  =	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
															UpperCAmelCase  :	int							  =	model_class(A					)
															UpperCAmelCase  :	List[str]							  =	inspect.signature(model.forward					)
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															UpperCAmelCase  :	Tuple							  =	[*signature.parameters.keys()]

															UpperCAmelCase  :	Optional[Any]							  =	["""pixel_values"""]
															self.assertListEqual(arg_names[:1]	,	A					)





	def 				_lowercase(						self					)    ->    Optional[Any]:
								UpperCAmelCase  :	Tuple							  =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*A					)





	def 				_lowercase(						self					)    ->    List[str]:
								def check_hidden_states_output(A	,	A	,	A					):
															UpperCAmelCase  :	Optional[Any]							  =	model_class(A					)
															model.to(A					)
															model.eval()

															with torch.no_grad():
																						UpperCAmelCase  :	Dict							  =	model(**self._prepare_for_class(A	,	A					)					)

															UpperCAmelCase  :	Tuple							  =	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

															UpperCAmelCase  :	Optional[Any]							  =	self.model_tester.num_stages
															self.assertEqual(len(A					)	,	expected_num_stages + 1					)

															# ConvNextV2'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]	,	)

								UpperCAmelCase  ,  UpperCAmelCase  :	str							  =	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
															UpperCAmelCase  :	str							  =	True
															check_hidden_states_output(A	,	A	,	A					)

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															UpperCAmelCase  :	int							  =	True

															check_hidden_states_output(A	,	A	,	A					)





	def 				_lowercase(						self					)    ->    Tuple:
								UpperCAmelCase  :	Dict							  =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*A					)






	@slow
	def 				_lowercase(						self					)    ->    Any:
								for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															UpperCAmelCase  :	Tuple							  =	ConvNextVaModel.from_pretrained(A					)
															self.assertIsNotNone(A					)




def    __lowerCamelCase						(      )   ->    Optional[int]:
							UpperCAmelCase  :	Optional[int]							  =	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""	)
							return image


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





	@cached_property
	def 				_lowercase(						self					)    ->    str:
								return AutoImageProcessor.from_pretrained("""facebook/convnextv2-tiny-1k-224"""					) if is_vision_available() else None






	@slow
	def 				_lowercase(						self					)    ->    List[Any]:
								UpperCAmelCase  :	Any							  =	ConvNextVaForImageClassification.from_pretrained("""facebook/convnextv2-tiny-1k-224"""					).to(A					)

								UpperCAmelCase  :	List[Any]							  =	self.default_image_processor
								UpperCAmelCase  :	Any							  =	prepare_img()
								UpperCAmelCase  :	Tuple							  =	preprocessor(images=A	,	return_tensors="""pt"""					).to(A					)

								# forward pass
								with torch.no_grad():
															UpperCAmelCase  :	Optional[Any]							  =	model(**A					)

								# verify the logits
								UpperCAmelCase  :	Dict							  =	torch.Size((1, 1000)					)
								self.assertEqual(outputs.logits.shape	,	A					)

								UpperCAmelCase  :	Dict							  =	torch.tensor([0.9_9_9_6, 0.1_9_6_6, -0.4_3_8_6]					).to(A					)
								self.assertTrue(torch.allclose(outputs.logits[0, :3]	,	A	,	atol=1e-4					)					)

