




'''simple docstring'''







from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


_lowerCamelCase							:						List[Any]							     =  logging.get_logger(__name__)

_lowerCamelCase							:						Any							     =  {
    'facebook/m2m100_418M': 'https://huggingface.co/facebook/m2m100_418M/resolve/main/config.json',
    # See all M2M100 models at https://huggingface.co/models?filter=m2m_100
}





class 					lowerCamelCase_							(	UpperCAmelCase_							):




					'''simple docstring'''






					lowercase__   =			"""m2m_100"""
					lowercase__   =			["""past_key_values"""]
					lowercase__   =			{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}






					def __init__(   self,  __UpperCamelCase=128_112,  __UpperCamelCase=1_024,  __UpperCamelCase=12,  __UpperCamelCase=4_096,  __UpperCamelCase=16,  __UpperCamelCase=12,  __UpperCamelCase=4_096,  __UpperCamelCase=16,  __UpperCamelCase=0.05,  __UpperCamelCase=0.05,  __UpperCamelCase=True,  __UpperCamelCase=True,  __UpperCamelCase="relu",  __UpperCamelCase=1_024,  __UpperCamelCase=0.1,  __UpperCamelCase=0.1,  __UpperCamelCase=0.0,  __UpperCamelCase=0.02,  __UpperCamelCase=2,  __UpperCamelCase=True,  __UpperCamelCase=1,  __UpperCamelCase=0,  __UpperCamelCase=2,  **__UpperCamelCase,  ):
							_snake_case     	=	vocab_size
							_snake_case     	=	max_position_embeddings
							_snake_case     	=	d_model
							_snake_case     	=	encoder_ffn_dim
							_snake_case     	=	encoder_layers
							_snake_case     	=	encoder_attention_heads
							_snake_case     	=	decoder_ffn_dim
							_snake_case     	=	decoder_layers
							_snake_case     	=	decoder_attention_heads
							_snake_case     	=	dropout
							_snake_case     	=	attention_dropout
							_snake_case     	=	activation_dropout
							_snake_case     	=	activation_function
							_snake_case     	=	init_std
							_snake_case     	=	encoder_layerdrop
							_snake_case     	=	decoder_layerdrop
							_snake_case     	=	use_cache
							_snake_case     	=	encoder_layers
							_snake_case     	=	scale_embedding  # scale factor will be sqrt(d_model) if True

							super().__init__(
							    pad_token_id=__UpperCamelCase,  bos_token_id=__UpperCamelCase,  eos_token_id=__UpperCamelCase,  is_encoder_decoder=__UpperCamelCase,  decoder_start_token_id=__UpperCamelCase,  **__UpperCamelCase,  )





class 					lowerCamelCase_							(	UpperCAmelCase_							):




					'''simple docstring'''






					@property
					def     __SCREAMING_SNAKE_CASE     (   self			):
							_snake_case     	=	OrderedDict(
							    [
							        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
							        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
							    ]			)

							if self.use_past:
									_snake_case     	=	{0: "batch"}
									_snake_case     	=	{0: "batch", 1: "past_decoder_sequence + sequence"}
							else:
									_snake_case     	=	{0: "batch", 1: "decoder_sequence"}
									_snake_case     	=	{0: "batch", 1: "decoder_sequence"}

							if self.use_past:
									self.fill_with_past_key_values_(__UpperCamelCase,  direction="inputs"			)
							return common_inputs






					def     __SCREAMING_SNAKE_CASE     (   self,  __UpperCamelCase,  __UpperCamelCase = -1,  __UpperCamelCase = -1,  __UpperCamelCase = False,  __UpperCamelCase = None,  ):
							# Copied from OnnxConfig.generate_dummy_inputs
							# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
							# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
							_snake_case     	=	compute_effective_axis_dimension(
							    __UpperCamelCase,  fixed_dimension=OnnxConfig.default_fixed_batch,  num_token_to_add=0			)

							# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
							_snake_case     	=	tokenizer.num_special_tokens_to_add(__UpperCamelCase			)
							_snake_case     	=	compute_effective_axis_dimension(
							    __UpperCamelCase,  fixed_dimension=OnnxConfig.default_fixed_sequence,  num_token_to_add=__UpperCamelCase			)

							# Generate dummy inputs according to compute batch and sequence
							_snake_case     	=	[" ".join([tokenizer.unk_token]			) * seq_length] * batch_size
							_snake_case     	=	dict(tokenizer(__UpperCamelCase,  return_tensors=__UpperCamelCase			)			)
							return common_inputs






					def     __SCREAMING_SNAKE_CASE     (   self,  __UpperCamelCase,  __UpperCamelCase = -1,  __UpperCamelCase = -1,  __UpperCamelCase = False,  __UpperCamelCase = None,  ):
							_snake_case     	=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase			)

							# Generate decoder inputs
							_snake_case     	=	seq_length if not self.use_past else 1
							_snake_case     	=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase,  __UpperCamelCase			)
							_snake_case     	=	{f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
							_snake_case     	=	dict(**__UpperCamelCase,  **__UpperCamelCase			)

							if self.use_past:
									if not is_torch_available():
											raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."			)
									else:
											import torch
									_snake_case	,   _snake_case     	=	common_inputs["input_ids"].shape
									_snake_case     	=	common_inputs["decoder_input_ids"].shape[1]
									_snake_case	,   _snake_case     	=	self.num_attention_heads
									_snake_case     	=	(
									    batch,
									    num_encoder_attention_heads,
									    encoder_seq_length,
									    self._config.hidden_size // num_encoder_attention_heads,
									)
									_snake_case     	=	decoder_seq_length + 3
									_snake_case     	=	(
									    batch,
									    num_decoder_attention_heads,
									    decoder_past_length,
									    self._config.hidden_size // num_decoder_attention_heads,
									)

									_snake_case     	=	torch.cat(
									    [common_inputs["decoder_attention_mask"], torch.ones(__UpperCamelCase,  __UpperCamelCase			)],  dim=1			)

									_snake_case     	=	[]
									# If the number of encoder and decoder layers are present in the model configuration, both are considered
									_snake_case	,   _snake_case     	=	self.num_layers
									_snake_case     	=	min(__UpperCamelCase,  __UpperCamelCase			)
									_snake_case     	=	max(__UpperCamelCase,  __UpperCamelCase			) - min_num_layers
									_snake_case     	=	"encoder" if num_encoder_layers > num_decoder_layers else "decoder"

									for _ in range(__UpperCamelCase			):
											common_inputs["past_key_values"].append(
											    (
											        torch.zeros(__UpperCamelCase			),
											        torch.zeros(__UpperCamelCase			),
											        torch.zeros(__UpperCamelCase			),
											        torch.zeros(__UpperCamelCase			),
											    )			)
									# TODO: test this.
									_snake_case     	=	encoder_shape if remaining_side_name == "encoder" else decoder_shape
									for _ in range(__UpperCamelCase,  __UpperCamelCase			):
											common_inputs["past_key_values"].append((torch.zeros(__UpperCamelCase			), torch.zeros(__UpperCamelCase			))			)
							return common_inputs






					lowercase__   =			_generate_dummy_inputs_for_default_and_seqaseq_lm











'''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


if is_torch_available():
						import torch

if is_vision_available():
						from PIL import Image

						from transformers import CLIPImageProcessor





class 					lowerCamelCase_							(	unittest.TestCase							):




					'''simple docstring'''






					def __init__(   self,  __UpperCamelCase,  __UpperCamelCase=7,  __UpperCamelCase=3,  __UpperCamelCase=18,  __UpperCamelCase=30,  __UpperCamelCase=400,  __UpperCamelCase=True,  __UpperCamelCase=None,  __UpperCamelCase=True,  __UpperCamelCase=None,  __UpperCamelCase=True,  __UpperCamelCase=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],  __UpperCamelCase=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],  __UpperCamelCase=True,  ):
							_snake_case     	=	size if size is not None else {"shortest_edge": 20}
							_snake_case     	=	crop_size if crop_size is not None else {"height": 18, "width": 18}
							_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
							_snake_case     	=	do_convert_rgb






					def     __SCREAMING_SNAKE_CASE     (   self			):
							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,
							    "do_convert_rgb": self.do_convert_rgb,
							}






					def     __SCREAMING_SNAKE_CASE     (   self,  __UpperCamelCase=False,  __UpperCamelCase=False,  __UpperCamelCase=False			):
							assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

							if equal_resolution:
									_snake_case     	=	[]
									for i in range(self.batch_size			):
											image_inputs.append(
											    np.random.randint(
											        255,  size=(self.num_channels, self.max_resolution, self.max_resolution),  dtype=np.uinta			)			)
							else:
									_snake_case     	=	[]
									for i in range(self.batch_size			):
											_snake_case	,   _snake_case     	=	np.random.choice(np.arange(self.min_resolution,  self.max_resolution			),  2			)
											image_inputs.append(np.random.randint(255,  size=(self.num_channels, width, height),  dtype=np.uinta			)			)

							if not numpify and not torchify:
									# PIL expects the channel dimension as last dimension
									_snake_case     	=	[Image.fromarray(np.moveaxis(__UpperCamelCase,  0,  -1			)			) for x in image_inputs]

							if torchify:
									_snake_case     	=	[torch.from_numpy(__UpperCamelCase			) for x in image_inputs]

							return image_inputs





@require_torch
@require_vision
class 					lowerCamelCase_							(	UpperCAmelCase_,	unittest.TestCase							):




					'''simple docstring'''






					lowercase__   =			CLIPImageProcessor if is_vision_available() else None






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_snake_case     	=	CLIPImageProcessingTester(self			)






					@property
					def     __SCREAMING_SNAKE_CASE     (   self			):
							return self.image_processor_tester.prepare_image_processor_dict()






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_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"			)			)
							self.assertTrue(hasattr(__UpperCamelCase,  "do_convert_rgb"			)			)






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_snake_case     	=	self.image_processing_class.from_dict(self.image_processor_dict			)
							self.assertEqual(image_processor.size,  {"shortest_edge": 20}			)
							self.assertEqual(image_processor.crop_size,  {"height": 18, "width": 18}			)

							_snake_case     	=	self.image_processing_class.from_dict(self.image_processor_dict,  size=42,  crop_size=84			)
							self.assertEqual(image_processor.size,  {"shortest_edge": 42}			)
							self.assertEqual(image_processor.crop_size,  {"height": 84, "width": 84}			)






					def     __SCREAMING_SNAKE_CASE     (   self			):
							pass






					def     __SCREAMING_SNAKE_CASE     (   self			):
							# Initialize image_processing
							_snake_case     	=	self.image_processing_class(**self.image_processor_dict			)
							# create random PIL images
							_snake_case     	=	self.image_processor_tester.prepare_inputs(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     __SCREAMING_SNAKE_CASE     (   self			):
							# Initialize image_processing
							_snake_case     	=	self.image_processing_class(**self.image_processor_dict			)
							# create random numpy tensors
							_snake_case     	=	self.image_processor_tester.prepare_inputs(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     __SCREAMING_SNAKE_CASE     (   self			):
							# Initialize image_processing
							_snake_case     	=	self.image_processing_class(**self.image_processor_dict			)
							# create random PyTorch tensors
							_snake_case     	=	self.image_processor_tester.prepare_inputs(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"],
							    ),  )





@require_torch
@require_vision
class 					lowerCamelCase_							(	UpperCAmelCase_,	unittest.TestCase							):




					'''simple docstring'''






					lowercase__   =			CLIPImageProcessor if is_vision_available() else None






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_snake_case     	=	CLIPImageProcessingTester(self,  num_channels=4			)
							_snake_case     	=	3






					@property
					def     __SCREAMING_SNAKE_CASE     (   self			):
							return self.image_processor_tester.prepare_image_processor_dict()






					def     __SCREAMING_SNAKE_CASE     (   self			):
							_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"			)			)
							self.assertTrue(hasattr(__UpperCamelCase,  "do_convert_rgb"			)			)






					def     __SCREAMING_SNAKE_CASE     (   self			):
							pass






					def     __SCREAMING_SNAKE_CASE     (   self			):
							# Initialize image_processing
							_snake_case     	=	self.image_processing_class(**self.image_processor_dict			)
							# create random PIL images
							_snake_case     	=	self.image_processor_tester.prepare_inputs(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.expected_encoded_image_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.expected_encoded_image_num_channels,
							        self.image_processor_tester.crop_size["height"],
							        self.image_processor_tester.crop_size["width"],
							    ),  )





