
from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__snake_case								=  logging.get_logger(__name__)

__snake_case								=  {
    """xlm-mlm-en-2048""": """https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json""",
    """xlm-mlm-ende-1024""": """https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json""",
    """xlm-mlm-enfr-1024""": """https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json""",
    """xlm-mlm-enro-1024""": """https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json""",
    """xlm-mlm-tlm-xnli15-1024""": """https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json""",
    """xlm-mlm-xnli15-1024""": """https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json""",
    """xlm-clm-enfr-1024""": """https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json""",
    """xlm-clm-ende-1024""": """https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json""",
    """xlm-mlm-17-1280""": """https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json""",
    """xlm-mlm-100-1280""": """https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json""",
}




class 						lowercase__  (						_UpperCAmelCase  ):
	A__    :   Optional[int]				       ="""xlm"""
	A__    :   Dict				       ={
	    """hidden_size""": """emb_dim""",
	    """num_attention_heads""": """n_heads""",
	    """num_hidden_layers""": """n_layers""",
	    """n_words""": """vocab_size""",  # For backward compatibility
	}
	def __init__(			self							:   Union[str, Any]       ,   UpperCAmelCase_							:   Dict=30145       ,   UpperCAmelCase_							:   Optional[Any]=2048       ,   UpperCAmelCase_							:   Tuple=12       ,   UpperCAmelCase_							:   str=16       ,   UpperCAmelCase_							:   Optional[int]=0.1       ,   UpperCAmelCase_							:   Union[str, Any]=0.1       ,   UpperCAmelCase_							:   List[Any]=True       ,   UpperCAmelCase_							:   Optional[int]=False       ,   UpperCAmelCase_							:   str=False       ,   UpperCAmelCase_							:   Optional[int]=False       ,   UpperCAmelCase_							:   Optional[int]=1       ,   UpperCAmelCase_							:   int=True       ,   UpperCAmelCase_							:   Dict=512       ,   UpperCAmelCase_							:   Optional[Any]=2048**-0.5       ,   UpperCAmelCase_							:   List[str]=1e-1_2       ,   UpperCAmelCase_							:   Optional[Any]=0.02       ,   UpperCAmelCase_							:   Union[str, Any]=0       ,   UpperCAmelCase_							:   int=1       ,   UpperCAmelCase_							:   Optional[Any]=2       ,   UpperCAmelCase_							:   Tuple=3       ,   UpperCAmelCase_							:   Any=5       ,   UpperCAmelCase_							:   Tuple=True       ,   UpperCAmelCase_							:   str="first"       ,   UpperCAmelCase_							:   str=True       ,   UpperCAmelCase_							:   Any=None       ,   UpperCAmelCase_							:   Optional[int]=True       ,   UpperCAmelCase_							:   List[str]=0.1       ,   UpperCAmelCase_							:   Any=5       ,   UpperCAmelCase_							:   str=5       ,   UpperCAmelCase_							:   Optional[Any]=0       ,   UpperCAmelCase_							:   Optional[Any]=0       ,   UpperCAmelCase_							:   List[Any]=2       ,   UpperCAmelCase_							:   Optional[Any]=0       ,   **UpperCAmelCase_							:   Optional[Any]       ,   ):
						SCREAMING_SNAKE_CASE__													= vocab_size
						SCREAMING_SNAKE_CASE__													= emb_dim
						SCREAMING_SNAKE_CASE__													= n_layers
						SCREAMING_SNAKE_CASE__													= n_heads
						SCREAMING_SNAKE_CASE__													= dropout
						SCREAMING_SNAKE_CASE__													= attention_dropout
						SCREAMING_SNAKE_CASE__													= gelu_activation
						SCREAMING_SNAKE_CASE__													= sinusoidal_embeddings
						SCREAMING_SNAKE_CASE__													= causal
						SCREAMING_SNAKE_CASE__													= asm
						SCREAMING_SNAKE_CASE__													= n_langs
						SCREAMING_SNAKE_CASE__													= use_lang_emb
						SCREAMING_SNAKE_CASE__													= layer_norm_eps
						SCREAMING_SNAKE_CASE__													= bos_index
						SCREAMING_SNAKE_CASE__													= eos_index
						SCREAMING_SNAKE_CASE__													= pad_index
						SCREAMING_SNAKE_CASE__													= unk_index
						SCREAMING_SNAKE_CASE__													= mask_index
						SCREAMING_SNAKE_CASE__													= is_encoder
						SCREAMING_SNAKE_CASE__													= max_position_embeddings
						SCREAMING_SNAKE_CASE__													= embed_init_std
						SCREAMING_SNAKE_CASE__													= init_std
						SCREAMING_SNAKE_CASE__													= summary_type
						SCREAMING_SNAKE_CASE__													= summary_use_proj
						SCREAMING_SNAKE_CASE__													= summary_activation
						SCREAMING_SNAKE_CASE__													= summary_proj_to_labels
						SCREAMING_SNAKE_CASE__													= summary_first_dropout
						SCREAMING_SNAKE_CASE__													= start_n_top
						SCREAMING_SNAKE_CASE__													= end_n_top
						SCREAMING_SNAKE_CASE__													= mask_token_id
						SCREAMING_SNAKE_CASE__													= lang_id

						if "n_words" in kwargs:
											SCREAMING_SNAKE_CASE__													= kwargs['n_words']

						super().__init__(pad_token_id=UpperCAmelCase_       ,   bos_token_id=UpperCAmelCase_       ,   **UpperCAmelCase_							)





class 						lowercase__  (						_UpperCAmelCase  ):
	@property
	def      A_				(			self							:   int							):
						if self.task == "multiple-choice":
											SCREAMING_SNAKE_CASE__													= {0: 'batch', 1: 'choice', 2: 'sequence'}
						else:
											SCREAMING_SNAKE_CASE__													= {0: 'batch', 1: 'sequence'}
						return OrderedDict(
						    [
						        ('input_ids', dynamic_axis),
						        ('attention_mask', dynamic_axis),
						        ('token_type_ids', dynamic_axis),
						    ]							)







from typing import List, Optional, Union

import numpy as np
import PIL.Image

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


__snake_case								=  logging.get_logger(__name__)




class 						lowercase__  (						_UpperCAmelCase  ):
	A__    :   List[str]				       =["""pixel_values"""]
	def __init__(			self							:   Dict       ,   UpperCAmelCase_							:   bool = True       ,   UpperCAmelCase_							:   int = 32       ,   UpperCAmelCase_							:   int=PILImageResampling.BILINEAR       ,   UpperCAmelCase_							:   bool = True       ,   **UpperCAmelCase_							:   Any       ,   ):
						SCREAMING_SNAKE_CASE__													= do_resize
						SCREAMING_SNAKE_CASE__													= do_rescale
						SCREAMING_SNAKE_CASE__													= size_divisor
						SCREAMING_SNAKE_CASE__													= resample
						super().__init__(**UpperCAmelCase_							)
	def      A_				(			self							:   Optional[int]       ,   UpperCAmelCase_							:   np.ndarray       ,   UpperCAmelCase_							:   int       ,   UpperCAmelCase_							:   Dict       ,   UpperCAmelCase_							:   Optional[ChannelDimension] = None       ,   **UpperCAmelCase_							:   Dict							):
						SCREAMING_SNAKE_CASE__						, SCREAMING_SNAKE_CASE__													= get_image_size(UpperCAmelCase_							)
						# Rounds the height and width down to the closest multiple of size_divisor
						SCREAMING_SNAKE_CASE__													= height // size_divisor * size_divisor
						SCREAMING_SNAKE_CASE__													= width // size_divisor * size_divisor
						SCREAMING_SNAKE_CASE__													= resize(UpperCAmelCase_       ,   (new_h, new_w)       ,   resample=UpperCAmelCase_       ,   data_format=UpperCAmelCase_       ,   **UpperCAmelCase_							)
						return image
	def      A_				(			self							:   Any       ,   UpperCAmelCase_							:   np.ndarray       ,   UpperCAmelCase_							:   float       ,   UpperCAmelCase_							:   Optional[ChannelDimension] = None       ,   **UpperCAmelCase_							:   List[str]							):
						return rescale(image=UpperCAmelCase_       ,   scale=UpperCAmelCase_       ,   data_format=UpperCAmelCase_       ,   **UpperCAmelCase_							)





	def      A_				(			self							:   Dict       ,   UpperCAmelCase_							:   Union["PIL.Image.Image", TensorType, List["PIL.Image.Image"], List[TensorType]]       ,   UpperCAmelCase_							:   Optional[bool] = None       ,   UpperCAmelCase_							:   Optional[int] = None       ,   UpperCAmelCase_							:   List[str]=None       ,   UpperCAmelCase_							:   Optional[bool] = None       ,   UpperCAmelCase_							:   Optional[Union[TensorType, str]] = None       ,   UpperCAmelCase_							:   ChannelDimension = ChannelDimension.FIRST       ,   **UpperCAmelCase_							:   List[Any]       ,   ):
						SCREAMING_SNAKE_CASE__													= do_resize if do_resize is not None else self.do_resize
						SCREAMING_SNAKE_CASE__													= do_rescale if do_rescale is not None else self.do_rescale
						SCREAMING_SNAKE_CASE__													= size_divisor if size_divisor is not None else self.size_divisor
						SCREAMING_SNAKE_CASE__													= resample if resample is not None else self.resample

						if do_resize and size_divisor is None:
											raise ValueError('size_divisor is required for resizing'							)

						SCREAMING_SNAKE_CASE__													= make_list_of_images(UpperCAmelCase_							)

						if not valid_images(UpperCAmelCase_							):
											raise ValueError('Invalid image(s)'							)

						# All transformations expect numpy arrays.
						SCREAMING_SNAKE_CASE__													= [to_numpy_array(UpperCAmelCase_							) for img in images]

						if do_resize:
											SCREAMING_SNAKE_CASE__													= [self.resize(UpperCAmelCase_       ,   size_divisor=UpperCAmelCase_       ,   resample=UpperCAmelCase_							) for image in images]

						if do_rescale:
											SCREAMING_SNAKE_CASE__													= [self.rescale(UpperCAmelCase_       ,   scale=1 / 255							) for image in images]

						SCREAMING_SNAKE_CASE__													= [to_channel_dimension_format(UpperCAmelCase_       ,   UpperCAmelCase_							) for image in images]

						SCREAMING_SNAKE_CASE__													= {'pixel_values': images}
						return BatchFeature(data=UpperCAmelCase_       ,   tensor_type=UpperCAmelCase_							)





