
'''simple docstring'''






import colorsys
import io

import cva
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import numpy as np
import torch
from matplotlib.backends.backend_agg import FigureCanvasAgg

from utils import img_tensorize


__lowercase	=    10_00

class 							_snake_case     :
	"""simple docstring"""





	def __init__(						self				: Optional[Any]					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: List[Any]=1.2					,						UpperCamelCase_				: Optional[int]="g"					,						UpperCamelCase_				: Optional[int]=0.5					,						UpperCamelCase_				: Optional[int]="-"					,						UpperCamelCase_				: Dict="test_out.jpg"					,						UpperCamelCase_				: int=True					,						UpperCamelCase_				: Dict=False					,						UpperCamelCase_				: List[Any]=None					,						UpperCamelCase_				: int=None					,						UpperCamelCase_				: List[str]=0.7					,						):
			if isinstance(UpperCamelCase_					,						torch.Tensor      ):
					lowerCAmelCase_   :       Optional[Any]    							=img.numpy().astype('''np.uint8'''      )
			if isinstance(UpperCamelCase_					,						UpperCamelCase_      ):
					lowerCAmelCase_   :       str    							=img_tensorize(UpperCamelCase_      )
			assert isinstance(UpperCamelCase_					,						np.ndarray      )

			lowerCAmelCase_							,		lowerCAmelCase_   :       List[Any]    							=img.shape[1], img.shape[0]
			lowerCAmelCase_   :       Union[str, Any]    							=mplfigure.Figure(frameon=UpperCamelCase_      )
			lowerCAmelCase_   :       Dict    							=fig.get_dpi()
			lowerCAmelCase_   :       Tuple    							=(width * scale + 1E-2) / dpi
			lowerCAmelCase_   :       int    							=(height * scale + 1E-2) / dpi
			fig.set_size_inches(UpperCamelCase_					,						UpperCamelCase_      )
			lowerCAmelCase_   :       Any    							=fig.add_axes([0.0, 0.0, 1.0, 1.0]      )
			ax.axis('''off'''      )
			ax.set_xlim(0.0					,						UpperCamelCase_      )
			ax.set_ylim(UpperCamelCase_      )

			lowerCAmelCase_   :       str    							=saveas
			lowerCAmelCase_   :       Optional[Any]    							=rgb
			lowerCAmelCase_   :       Optional[Any]    							=pynb
			lowerCAmelCase_   :       Any    							=img
			lowerCAmelCase_   :       Any    							=edgecolor
			lowerCAmelCase_   :       Union[str, Any]    							=0.5
			lowerCAmelCase_   :       Optional[int]    							=linestyle
			lowerCAmelCase_   :       List[Any]    							=int(np.sqrt(min(UpperCamelCase_					,						UpperCamelCase_      )      ) * scale // 3      )
			lowerCAmelCase_   :       Union[str, Any]    							=width
			lowerCAmelCase_   :       Tuple    							=height
			lowerCAmelCase_   :       int    							=scale
			lowerCAmelCase_   :       Any    							=fig
			lowerCAmelCase_   :       int    							=ax
			lowerCAmelCase_   :       List[Any]    							=pad
			lowerCAmelCase_   :       Tuple    							=idaobj
			lowerCAmelCase_   :       List[Any]    							=idaattr
			lowerCAmelCase_   :       List[str]    							=FigureCanvasAgg(UpperCamelCase_      )




	def 	__A      (						self				: int					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: List[Any]=None      ):
			if color is None:
					lowerCAmelCase_   :       Tuple    							=self.edgecolor
			((lowerCAmelCase_)							,		(lowerCAmelCase_)							,		(lowerCAmelCase_)							,		(lowerCAmelCase_))   :       Union[str, Any]    							=box
			lowerCAmelCase_   :       Tuple    							=xa - xa
			lowerCAmelCase_   :       List[Any]    							=ya - ya
			self.ax.add_patch(
			    mpl.patches.Rectangle(
			        (xa, ya)					,						UpperCamelCase_					,						UpperCamelCase_					,						fill=UpperCamelCase_					,						edgecolor=UpperCamelCase_					,						linewidth=self.font_size // 3					,						alpha=self.alpha					,						linestyle=self.linestyle					,						)      )




	def 	__A      (						self				: Optional[Any]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: List[Any]=None					,						UpperCamelCase_				: Any=None					,						UpperCamelCase_				: Dict=None					,						UpperCamelCase_				: Dict=None      ):
			if len(boxes.shape      ) > 2:
					lowerCAmelCase_   :       Optional[Any]    							=boxes[0]
			if len(obj_ids.shape      ) > 1:
					lowerCAmelCase_   :       List[str]    							=obj_ids[0]
			if len(obj_scores.shape      ) > 1:
					lowerCAmelCase_   :       Union[str, Any]    							=obj_scores[0]
			if len(attr_ids.shape      ) > 1:
					lowerCAmelCase_   :       Optional[Any]    							=attr_ids[0]
			if len(attr_scores.shape      ) > 1:
					lowerCAmelCase_   :       Tuple    							=attr_scores[0]
			if isinstance(UpperCamelCase_					,						torch.Tensor      ):
					lowerCAmelCase_   :       Any    							=boxes.numpy()
			if isinstance(UpperCamelCase_					,						UpperCamelCase_      ):
					lowerCAmelCase_   :       Optional[int]    							=np.array(UpperCamelCase_      )
			assert isinstance(UpperCamelCase_					,						np.ndarray      )
			lowerCAmelCase_   :       Any    							=np.prod(boxes[:, 2:] - boxes[:, :2]					,						axis=1      )
			lowerCAmelCase_   :       Optional[Any]    							=np.argsort(-areas      ).tolist()
			lowerCAmelCase_   :       Optional[int]    							=boxes[sorted_idxs] if boxes is not None else None
			lowerCAmelCase_   :       Union[str, Any]    							=obj_ids[sorted_idxs] if obj_ids is not None else None
			lowerCAmelCase_   :       List[str]    							=obj_scores[sorted_idxs] if obj_scores is not None else None
			lowerCAmelCase_   :       List[str]    							=attr_ids[sorted_idxs] if attr_ids is not None else None
			lowerCAmelCase_   :       Any    							=attr_scores[sorted_idxs] if attr_scores is not None else None

			lowerCAmelCase_   :       Optional[Any]    							=[self._random_color(maximum=1      ) for _ in range(len(UpperCamelCase_      )      )]
			lowerCAmelCase_   :       List[Any]    							=[assigned_colors[idx] for idx in sorted_idxs]
			if obj_ids is not None:
					lowerCAmelCase_   :       str    							=self._create_text_labels_attr(UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_      )
					for i in range(len(UpperCamelCase_      )      ):
							lowerCAmelCase_   :       Tuple    							=assigned_colors[i]
							self.add_box(boxes[i]					,						UpperCamelCase_      )
							self.draw_labels(labels[i]					,						boxes[i]					,						UpperCamelCase_      )




	def 	__A      (						self				: Optional[Any]					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Optional[int]      ):
			lowerCAmelCase_							,		lowerCAmelCase_							,		lowerCAmelCase_							,		lowerCAmelCase_   :       int    							=box
			lowerCAmelCase_   :       Tuple    							=(xa, ya)
			lowerCAmelCase_   :       List[str]    							=(ya - ya) * (xa - xa)
			lowerCAmelCase_   :       Tuple    							=_SMALL_OBJ * self.scale
			if instance_area < small or ya - ya < 40 * self.scale:
					if ya >= self.height - 5:
							lowerCAmelCase_   :       Tuple    							=(xa, ya)
					else:
							lowerCAmelCase_   :       List[Any]    							=(xa, ya)

			lowerCAmelCase_   :       Optional[Any]    							=(ya - ya) / np.sqrt(self.height * self.width      )
			lowerCAmelCase_   :       Union[str, Any]    							=self._change_color_brightness(UpperCamelCase_					,						brightness_factor=0.7      )
			lowerCAmelCase_   :       Optional[Any]    							=np.clip((height_ratio - 0.0_2) / 0.0_8 + 1					,						1.2					,						2      )
			font_size *= 0.7_5 * self.font_size

			self.draw_text(
			    text=UpperCamelCase_					,						position=UpperCamelCase_					,						color=UpperCamelCase_					,						)




	def 	__A      (						self				: List[str]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: str="g"					,						UpperCamelCase_				: int="left"					,						):
			lowerCAmelCase_   :       Any    							=0
			lowerCAmelCase_   :       List[Any]    							=self.font_size
			lowerCAmelCase_   :       Dict    							=np.maximum(list(mplc.to_rgb(UpperCamelCase_      )      )					,						0.2      )
			lowerCAmelCase_   :       Dict    							=max(0.8					,						np.max(UpperCamelCase_      )      )
			lowerCAmelCase_   :       List[str]    							={
			    '''facecolor''': '''black''',
			    '''alpha''': self.alpha,
			    '''pad''': self.pad,
			    '''edgecolor''': '''none''',
			}
			lowerCAmelCase_							,		lowerCAmelCase_   :       str    							=position
			self.ax.text(
			    UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_					,						size=font_size * self.scale					,						family='''sans-serif'''					,						bbox=UpperCamelCase_					,						verticalalignment='''top'''					,						horizontalalignment=UpperCamelCase_					,						color=UpperCamelCase_					,						zorder=10					,						rotation=UpperCamelCase_					,						)




	def 	__A      (						self				: str					,						UpperCamelCase_				: Union[str, Any]=None      ):
			if saveas is None:
					lowerCAmelCase_   :       Optional[int]    							=self.saveas
			if saveas.lower().endswith('''.jpg'''      ) or saveas.lower().endswith('''.png'''      ):
					cva.imwrite(
					    UpperCamelCase_					,						self._get_buffer()[:, :, ::-1]					,						)
			else:
					self.fig.savefig(UpperCamelCase_      )




	def 	__A      (						self				: List[str]					,						UpperCamelCase_				: List[Any]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: int      ):
			lowerCAmelCase_   :       Union[str, Any]    							=[self.idaobj[i] for i in classes]
			lowerCAmelCase_   :       Dict    							=[self.idaattr[i] for i in attr_classes]
			lowerCAmelCase_   :       List[Any]    							=[
			    F'{label} {score:.2f} {attr} {attr_score:.2f}'
			    for label, score, attr, attr_score in zip(UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_					,						UpperCamelCase_      )
			]
			return labels




	def 	__A      (						self				: Optional[Any]					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Dict      ):
			lowerCAmelCase_   :       Tuple    							=[self.idaobj[i] for i in classes]
			if scores is not None:
					if labels is None:
							lowerCAmelCase_   :       int    							=['''{:.0f}%'''.format(s * 100      ) for s in scores]
					else:
							lowerCAmelCase_   :       Tuple    							=['''{} {:.0f}%'''.format(UpperCamelCase_					,						s * 100      ) for li, s in zip(UpperCamelCase_					,						UpperCamelCase_      )]
			return labels




	def 	__A      (						self				: List[str]					,						UpperCamelCase_				: Optional[Any]=255      ):
			lowerCAmelCase_   :       str    							=np.random.randint(0					,						len(_COLORS      )      )
			lowerCAmelCase_   :       Union[str, Any]    							=_COLORS[idx] * maximum
			if not self.rgb:
					lowerCAmelCase_   :       Dict    							=ret[::-1]
			return ret




	def 	__A      (						self				: Union[str, Any]      ):
			if not self.pynb:
					lowerCAmelCase_							,		lowerCAmelCase_   :       List[Any]    							=self.canvas.print_to_buffer()
					if (width, height) != (self.width, self.height):
							lowerCAmelCase_   :       str    							=cva.resize(self.img					,						(width, height)      )
					else:
							lowerCAmelCase_   :       Dict    							=self.img
			else:
					lowerCAmelCase_   :       List[str]    							=io.BytesIO()  # works for cairo backend
					self.canvas.print_rgba(UpperCamelCase_      )
					lowerCAmelCase_							,		lowerCAmelCase_   :       str    							=self.width, self.height
					lowerCAmelCase_   :       Tuple    							=buf.getvalue()
					lowerCAmelCase_   :       List[str]    							=self.img

			lowerCAmelCase_   :       List[Any]    							=np.frombuffer(UpperCamelCase_					,						dtype='''uint8'''      )
			lowerCAmelCase_   :       List[str]    							=buffer.reshape(UpperCamelCase_					,						UpperCamelCase_					,						4      )
			lowerCAmelCase_							,		lowerCAmelCase_   :       Tuple    							=np.split(UpperCamelCase_					,						[3]					,						axis=2      )

			try:
					import numexpr as ne  # fuse them with numexpr

					lowerCAmelCase_   :       int    							=ne.evaluate('''img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)'''      )
			except ImportError:
					lowerCAmelCase_   :       Tuple    							=alpha.astype('''float32'''      ) / 2_5_5.0
					lowerCAmelCase_   :       Any    							=img * (1 - alpha) + rgb * alpha

			return visualized_image.astype('''uint8'''      )





	def 	__A      (						self				: int					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: str      ):
			assert brightness_factor >= -1.0 and brightness_factor <= 1.0
			lowerCAmelCase_   :       Optional[int]    							=mplc.to_rgb(UpperCamelCase_      )
			lowerCAmelCase_   :       Any    							=colorsys.rgb_to_hls(*mplc.to_rgb(UpperCamelCase_      )      )
			lowerCAmelCase_   :       Optional[Any]    							=polygon_color[1] + (brightness_factor * polygon_color[1])
			lowerCAmelCase_   :       List[str]    							=0.0 if modified_lightness < 0.0 else modified_lightness
			lowerCAmelCase_   :       List[str]    							=1.0 if modified_lightness > 1.0 else modified_lightness
			lowerCAmelCase_   :       Any    							=colorsys.hls_to_rgb(polygon_color[0]					,						UpperCamelCase_					,						polygon_color[2]      )
			return modified_color







__lowercase	=    (
    np.array(
        [
            0.000,
            0.447,
            0.741,
            0.850,
            0.325,
            0.098,
            0.929,
            0.694,
            0.125,
            0.494,
            0.184,
            0.556,
            0.466,
            0.674,
            0.188,
            0.301,
            0.745,
            0.933,
            0.635,
            0.078,
            0.184,
            0.300,
            0.300,
            0.300,
            0.600,
            0.600,
            0.600,
            1.000,
            0.000,
            0.000,
            1.000,
            0.500,
            0.000,
            0.749,
            0.749,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.333,
            0.333,
            0.000,
            0.333,
            0.667,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            0.333,
            0.000,
            0.667,
            0.667,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.667,
            0.000,
            1.000,
            1.000,
            0.000,
            0.000,
            0.333,
            0.500,
            0.000,
            0.667,
            0.500,
            0.000,
            1.000,
            0.500,
            0.333,
            0.000,
            0.500,
            0.333,
            0.333,
            0.500,
            0.333,
            0.667,
            0.500,
            0.333,
            1.000,
            0.500,
            0.667,
            0.000,
            0.500,
            0.667,
            0.333,
            0.500,
            0.667,
            0.667,
            0.500,
            0.667,
            1.000,
            0.500,
            1.000,
            0.000,
            0.500,
            1.000,
            0.333,
            0.500,
            1.000,
            0.667,
            0.500,
            1.000,
            1.000,
            0.500,
            0.000,
            0.333,
            1.000,
            0.000,
            0.667,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            0.000,
            1.000,
            0.333,
            0.333,
            1.000,
            0.333,
            0.667,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            0.000,
            1.000,
            0.667,
            0.333,
            1.000,
            0.667,
            0.667,
            1.000,
            0.667,
            1.000,
            1.000,
            1.000,
            0.000,
            1.000,
            1.000,
            0.333,
            1.000,
            1.000,
            0.667,
            1.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.167,
            0.000,
            0.000,
            0.333,
            0.000,
            0.000,
            0.500,
            0.000,
            0.000,
            0.667,
            0.000,
            0.000,
            0.833,
            0.000,
            0.000,
            1.000,
            0.000,
            0.000,
            0.000,
            0.143,
            0.143,
            0.143,
            0.857,
            0.857,
            0.857,
            1.000,
            1.000,
            1.000,
        ]
    )
    .astype(np.floataa)
    .reshape(-1, 3)
)








'''simple docstring'''






from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import (
							    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TFXLMForMultipleChoice,
							    TFXLMForQuestionAnsweringSimple,
							    TFXLMForSequenceClassification,
							    TFXLMForTokenClassification,
							    TFXLMModel,
							    TFXLMWithLMHeadModel,
							    XLMConfig,
							)

class 							_snake_case     :
	"""simple docstring"""





	def __init__(						self				: str					,						UpperCamelCase_				: Union[str, Any]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=parent
			lowerCAmelCase_   :       Any    							=13
			lowerCAmelCase_   :       str    							=7
			lowerCAmelCase_   :       Optional[Any]    							=True
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       List[str]    							=True
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       Dict    							=True
			lowerCAmelCase_   :       Union[str, Any]    							=False
			lowerCAmelCase_   :       List[Any]    							=False
			lowerCAmelCase_   :       Optional[int]    							=False
			lowerCAmelCase_   :       Union[str, Any]    							=2
			lowerCAmelCase_   :       List[str]    							=99
			lowerCAmelCase_   :       Optional[int]    							=0
			lowerCAmelCase_   :       Optional[int]    							=32
			lowerCAmelCase_   :       Dict    							=2
			lowerCAmelCase_   :       Dict    							=4
			lowerCAmelCase_   :       Tuple    							=0.1
			lowerCAmelCase_   :       Tuple    							=0.1
			lowerCAmelCase_   :       Tuple    							=512
			lowerCAmelCase_   :       Dict    							=16
			lowerCAmelCase_   :       List[Any]    							=2
			lowerCAmelCase_   :       Optional[int]    							=0.0_2
			lowerCAmelCase_   :       int    							=3
			lowerCAmelCase_   :       int    							=4
			lowerCAmelCase_   :       Union[str, Any]    							='''last'''
			lowerCAmelCase_   :       Optional[int]    							=True
			lowerCAmelCase_   :       Any    							=None
			lowerCAmelCase_   :       int    							=0




	def 	__A      (						self				: Dict      ):
			lowerCAmelCase_   :       List[Any]    							=ids_tensor([self.batch_size, self.seq_length]					,						self.vocab_size      )
			lowerCAmelCase_   :       Union[str, Any]    							=random_attention_mask([self.batch_size, self.seq_length]					,						dtype=tf.floataa      )

			lowerCAmelCase_   :       List[str]    							=None
			if self.use_input_lengths:
					lowerCAmelCase_   :       Optional[Any]    							=(
					    ids_tensor([self.batch_size]					,						vocab_size=2      ) + self.seq_length - 2
					)  # small variation of seq_length

			lowerCAmelCase_   :       str    							=None
			if self.use_token_type_ids:
					lowerCAmelCase_   :       Optional[Any]    							=ids_tensor([self.batch_size, self.seq_length]					,						self.n_langs      )

			lowerCAmelCase_   :       Optional[int]    							=None
			lowerCAmelCase_   :       str    							=None
			lowerCAmelCase_   :       Dict    							=None
			if self.use_labels:
					lowerCAmelCase_   :       int    							=ids_tensor([self.batch_size]					,						self.type_sequence_label_size      )
					lowerCAmelCase_   :       int    							=ids_tensor([self.batch_size, self.seq_length]					,						self.num_labels      )
					lowerCAmelCase_   :       int    							=ids_tensor([self.batch_size]					,						2					,						dtype=tf.floataa      )
					lowerCAmelCase_   :       Optional[Any]    							=ids_tensor([self.batch_size]					,						self.num_choices      )

			lowerCAmelCase_   :       Tuple    							=XLMConfig(
			    vocab_size=self.vocab_size					,						n_special=self.n_special					,						emb_dim=self.hidden_size					,						n_layers=self.num_hidden_layers					,						n_heads=self.num_attention_heads					,						dropout=self.hidden_dropout_prob					,						attention_dropout=self.attention_probs_dropout_prob					,						gelu_activation=self.gelu_activation					,						sinusoidal_embeddings=self.sinusoidal_embeddings					,						asm=self.asm					,						causal=self.causal					,						n_langs=self.n_langs					,						max_position_embeddings=self.max_position_embeddings					,						initializer_range=self.initializer_range					,						summary_type=self.summary_type					,						use_proj=self.use_proj					,						bos_token_id=self.bos_token_id					,						)

			return (
			    config,
			    input_ids,
			    token_type_ids,
			    input_lengths,
			    sequence_labels,
			    token_labels,
			    is_impossible_labels,
			    choice_labels,
			    input_mask,
			)




	def 	__A      (						self				: Any					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Tuple					,						):
			lowerCAmelCase_   :       int    							=TFXLMModel(config=UpperCamelCase_      )
			lowerCAmelCase_   :       Optional[int]    							={'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
			lowerCAmelCase_   :       Union[str, Any]    							=model(UpperCamelCase_      )

			lowerCAmelCase_   :       Union[str, Any]    							=[input_ids, input_mask]
			lowerCAmelCase_   :       List[Any]    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.last_hidden_state.shape					,						(self.batch_size, self.seq_length, self.hidden_size)      )




	def 	__A      (						self				: List[Any]					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: List[Any]					,						):
			lowerCAmelCase_   :       List[str]    							=TFXLMWithLMHeadModel(UpperCamelCase_      )

			lowerCAmelCase_   :       List[Any]    							={'''input_ids''': input_ids, '''lengths''': input_lengths, '''langs''': token_type_ids}
			lowerCAmelCase_   :       Tuple    							=model(UpperCamelCase_      )

			lowerCAmelCase_   :       int    							=outputs

			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.seq_length, self.vocab_size)      )




	def 	__A      (						self				: int					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=TFXLMForQuestionAnsweringSimple(UpperCamelCase_      )

			lowerCAmelCase_   :       str    							={'''input_ids''': input_ids, '''lengths''': input_lengths}

			lowerCAmelCase_   :       Optional[Any]    							=model(UpperCamelCase_      )

			self.parent.assertEqual(result.start_logits.shape					,						(self.batch_size, self.seq_length)      )
			self.parent.assertEqual(result.end_logits.shape					,						(self.batch_size, self.seq_length)      )




	def 	__A      (						self				: Tuple					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: List[Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       List[Any]    							=TFXLMForSequenceClassification(UpperCamelCase_      )

			lowerCAmelCase_   :       List[Any]    							={'''input_ids''': input_ids, '''lengths''': input_lengths}

			lowerCAmelCase_   :       int    							=model(UpperCamelCase_      )

			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.type_sequence_label_size)      )




	def 	__A      (						self				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Any					,						UpperCamelCase_				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[int]					,						UpperCamelCase_				: List[str]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       Optional[Any]    							=self.num_labels
			lowerCAmelCase_   :       int    							=TFXLMForTokenClassification(config=UpperCamelCase_      )
			lowerCAmelCase_   :       Optional[int]    							={'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
			lowerCAmelCase_   :       str    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.seq_length, self.num_labels)      )




	def 	__A      (						self				: int					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: str					,						UpperCamelCase_				: Tuple					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: Optional[int]					,						):
			lowerCAmelCase_   :       List[str]    							=self.num_choices
			lowerCAmelCase_   :       Tuple    							=TFXLMForMultipleChoice(config=UpperCamelCase_      )
			lowerCAmelCase_   :       str    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Union[str, Any]    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Any    							=tf.tile(tf.expand_dims(UpperCamelCase_					,						1      )					,						(1, self.num_choices, 1)      )
			lowerCAmelCase_   :       Optional[Any]    							={
			    '''input_ids''': multiple_choice_inputs_ids,
			    '''attention_mask''': multiple_choice_input_mask,
			    '''token_type_ids''': multiple_choice_token_type_ids,
			}
			lowerCAmelCase_   :       Any    							=model(UpperCamelCase_      )
			self.parent.assertEqual(result.logits.shape					,						(self.batch_size, self.num_choices)      )





	def 	__A      (						self				: Union[str, Any]      ):
			lowerCAmelCase_   :       List[Any]    							=self.prepare_config_and_inputs()
			(
			    (
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		(
			    lowerCAmelCase_
			)							,		
			)   :       List[str]    							=config_and_inputs
			lowerCAmelCase_   :       List[Any]    							={
			    '''input_ids''': input_ids,
			    '''token_type_ids''': token_type_ids,
			    '''langs''': token_type_ids,
			    '''lengths''': input_lengths,
			}
			return config, inputs_dict







@require_tf
class 							_snake_case     (  lowerCAmelCase_						,    lowerCAmelCase_						,    unittest.TestCase ):
	"""simple docstring"""





	_UpperCamelCase							:  Union[str, Any]								=		(
	    (
	        TFXLMModel,
	        TFXLMWithLMHeadModel,
	        TFXLMForSequenceClassification,
	        TFXLMForQuestionAnsweringSimple,
	        TFXLMForTokenClassification,
	        TFXLMForMultipleChoice,
	    )
	    if is_tf_available()
	    else ()
	)
	_UpperCamelCase							:  Union[str, Any]								=		(
	    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
	)  # TODO (PVP): Check other models whether language generation is also applicable
	_UpperCamelCase							:  List[str]								=		(
	    {
	        '''feature-extraction''': TFXLMModel,
	        '''fill-mask''': TFXLMWithLMHeadModel,
	        '''question-answering''': TFXLMForQuestionAnsweringSimple,
	        '''text-classification''': TFXLMForSequenceClassification,
	        '''text-generation''': TFXLMWithLMHeadModel,
	        '''token-classification''': TFXLMForTokenClassification,
	        '''zero-shot''': TFXLMForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)
	_UpperCamelCase							:  Optional[int]								=		False
	_UpperCamelCase							:  int								=		False




	def 	__A      (						self				: Optional[Any]					,						UpperCamelCase_				: Dict					,						UpperCamelCase_				: Union[str, Any]					,						UpperCamelCase_				: int					,						UpperCamelCase_				: Optional[Any]					,						UpperCamelCase_				: List[str]      ):
			if (
			    pipeline_test_casse_name == "QAPipelineTests"
			    and tokenizer_name is not None
			    and not tokenizer_name.endswith('''Fast'''      )
			):
					# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
					# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
					# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
					return True

			return False




	def 	__A      (						self				: List[Any]      ):
			lowerCAmelCase_   :       Union[str, Any]    							=TFXLMModelTester(self      )
			lowerCAmelCase_   :       Optional[Any]    							=ConfigTester(self					,						config_class=UpperCamelCase_					,						emb_dim=37      )




	def 	__A      (						self				: Union[str, Any]      ):
			self.config_tester.run_common_tests()




	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       List[str]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_model(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[int]      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_lm_head(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[Any]      ):
			lowerCAmelCase_   :       int    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_qa(*UpperCamelCase_      )




	def 	__A      (						self				: int      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_sequence_classif(*UpperCamelCase_      )




	def 	__A      (						self				: Optional[int]      ):
			lowerCAmelCase_   :       Optional[int]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_token_classification(*UpperCamelCase_      )




	def 	__A      (						self				: List[Any]      ):
			lowerCAmelCase_   :       List[str]    							=self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_xlm_for_multiple_choice(*UpperCamelCase_      )





	@slow
	def 	__A      (						self				: List[Any]      ):
			for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					lowerCAmelCase_   :       List[str]    							=TFXLMModel.from_pretrained(UpperCamelCase_      )
					self.assertIsNotNone(UpperCamelCase_      )







@require_tf
class 							_snake_case     (  unittest.TestCase ):
	"""simple docstring"""





	@slow
	def 	__A      (						self				: Dict      ):
			lowerCAmelCase_   :       Any    							=TFXLMWithLMHeadModel.from_pretrained('''xlm-mlm-en-2048'''      )
			lowerCAmelCase_   :       List[str]    							=tf.convert_to_tensor([[14, 447]]					,						dtype=tf.intaa      )  # the president
			lowerCAmelCase_   :       List[Any]    							=[
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			    14,
			    447,
			]  # the president the president the president the president the president the president the president the president the president the president
			# TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
			lowerCAmelCase_   :       Optional[int]    							=model.generate(UpperCamelCase_					,						do_sample=UpperCamelCase_      )
			self.assertListEqual(output_ids[0].numpy().tolist()					,						UpperCamelCase_      )






