


'''simple docstring'''


import tempfile

import numpy as np
import torch
from transformers import AutoTokenizer, TaEncoderModel

from diffusers import DDPMScheduler, UNetaDConditionModel
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.pipelines.deepfloyd_if import IFWatermarker
from diffusers.utils.testing_utils import torch_device

from ..test_pipelines_common import to_np







class 							__magic_name__	:

     """simple docstring"""






     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          torch.manual_seed(0		)
          __A	:       Any      =							TaEncoderModel.from_pretrained("hf-internal-testing/tiny-random-t5"		)

          torch.manual_seed(0		)
          __A	:       int      =							AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-t5"		)

          torch.manual_seed(0		)
          __A	:       List[str]      =							UNetaDConditionModel(
              sample_size=32			,     layers_per_block=1			,     block_out_channels=[32, 64]			,     down_block_types=[
                  "ResnetDownsampleBlock2D",
                  "SimpleCrossAttnDownBlock2D",
              ]			,     mid_block_type="UNetMidBlock2DSimpleCrossAttn"			,     up_block_types=["SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"]			,     in_channels=3			,     out_channels=6			,     cross_attention_dim=32			,     encoder_hid_dim=32			,     attention_head_dim=8			,     addition_embed_type="text"			,     addition_embed_type_num_heads=2			,     cross_attention_norm="group_norm"			,     resnet_time_scale_shift="scale_shift"			,     act_fn="gelu"			,     )
          unet.set_attn_processor(AttnAddedKVProcessor()		)  # For reproducibility tests

          torch.manual_seed(0		)
          __A	:       Tuple      =							DDPMScheduler(
              num_train_timesteps=1000			,     beta_schedule="squaredcos_cap_v2"			,     beta_start=0.0001			,     beta_end=0.02			,     thresholding=lowerCamelCase			,     dynamic_thresholding_ratio=0.95			,     sample_max_value=1.0			,     prediction_type="epsilon"			,     variance_type="learned_range"			,     )

          torch.manual_seed(0		)
          __A	:       Any      =							IFWatermarker()

          return {
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "unet": unet,
              "scheduler": scheduler,
              "watermarker": watermarker,
              "safety_checker": None,
              "feature_extractor": None,
          }


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          torch.manual_seed(0		)
          __A	:       Optional[int]      =							TaEncoderModel.from_pretrained("hf-internal-testing/tiny-random-t5"		)

          torch.manual_seed(0		)
          __A	:       Dict      =							AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-t5"		)

          torch.manual_seed(0		)
          __A	:       str      =							UNetaDConditionModel(
              sample_size=32			,     layers_per_block=[1, 2]			,     block_out_channels=[32, 64]			,     down_block_types=[
                  "ResnetDownsampleBlock2D",
                  "SimpleCrossAttnDownBlock2D",
              ]			,     mid_block_type="UNetMidBlock2DSimpleCrossAttn"			,     up_block_types=["SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"]			,     in_channels=6			,     out_channels=6			,     cross_attention_dim=32			,     encoder_hid_dim=32			,     attention_head_dim=8			,     addition_embed_type="text"			,     addition_embed_type_num_heads=2			,     cross_attention_norm="group_norm"			,     resnet_time_scale_shift="scale_shift"			,     act_fn="gelu"			,     class_embed_type="timestep"			,     mid_block_scale_factor=1.414			,     time_embedding_act_fn="gelu"			,     time_embedding_dim=32			,     )
          unet.set_attn_processor(AttnAddedKVProcessor()		)  # For reproducibility tests

          torch.manual_seed(0		)
          __A	:       Optional[int]      =							DDPMScheduler(
              num_train_timesteps=1000			,     beta_schedule="squaredcos_cap_v2"			,     beta_start=0.0001			,     beta_end=0.02			,     thresholding=lowerCamelCase			,     dynamic_thresholding_ratio=0.95			,     sample_max_value=1.0			,     prediction_type="epsilon"			,     variance_type="learned_range"			,     )

          torch.manual_seed(0		)
          __A	:       List[str]      =							DDPMScheduler(
              num_train_timesteps=1000			,     beta_schedule="squaredcos_cap_v2"			,     beta_start=0.0001			,     beta_end=0.02			,     )

          torch.manual_seed(0		)
          __A	:       List[Any]      =							IFWatermarker()

          return {
              "text_encoder": text_encoder,
              "tokenizer": tokenizer,
              "unet": unet,
              "scheduler": scheduler,
              "image_noising_scheduler": image_noising_scheduler,
              "watermarker": watermarker,
              "safety_checker": None,
              "feature_extractor": None,
          }


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       List[str]      =							self.get_dummy_components()
          __A	:       Any      =							self.pipeline_class(**lowerCamelCase		)
          pipe.to(lowerCamelCase		)
          pipe.set_progress_bar_config(disable=lowerCamelCase		)

          __A	:       Optional[int]      =							self.get_dummy_inputs(lowerCamelCase		)

          __A	:       Optional[int]      =							inputs["prompt"]
          __A	:       Optional[int]      =							inputs["generator"]
          __A	:       List[str]      =							inputs["num_inference_steps"]
          __A	:       str      =							inputs["output_type"]

          if "image" in inputs:
               __A	:       List[Any]      =							inputs["image"]
          else:
               __A	:       Tuple      =							None

          if "mask_image" in inputs:
               __A	:       Optional[int]      =							inputs["mask_image"]
          else:
               __A	:       List[str]      =							None

          if "original_image" in inputs:
               __A	:       Tuple      =							inputs["original_image"]
          else:
               __A	:       List[Any]      =							None

          __A  ,__A	:       int      =							pipe.encode_prompt(lowerCamelCase		)

          # inputs with prompt converted to embeddings
          __A	:       Tuple      =							{
              "prompt_embeds": prompt_embeds,
              "negative_prompt_embeds": negative_prompt_embeds,
              "generator": generator,
              "num_inference_steps": num_inference_steps,
              "output_type": output_type,
          }

          if image is not None:
               __A	:       Union[str, Any]      =							image

          if mask_image is not None:
               __A	:       Optional[Any]      =							mask_image

          if original_image is not None:
               __A	:       List[Any]      =							original_image

          # set all optional components to None
          for optional_component in pipe._optional_components:
               setattr(lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase		)

          __A	:       List[Any]      =							pipe(**lowerCamelCase		)[0]

          with tempfile.TemporaryDirectory() as tmpdir:
               pipe.save_pretrained(lowerCamelCase		)
               __A	:       Dict      =							self.pipeline_class.from_pretrained(lowerCamelCase		)
               pipe_loaded.to(lowerCamelCase		)
               pipe_loaded.set_progress_bar_config(disable=lowerCamelCase		)

          pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()		)  # For reproducibility tests

          for optional_component in pipe._optional_components:
               self.assertTrue(
                   getattr(lowerCamelCase			,     lowerCamelCase		) is None			,     f"`{optional_component}` did not stay set to None after loading."			,     )

          __A	:       Dict      =							self.get_dummy_inputs(lowerCamelCase		)

          __A	:       List[str]      =							inputs["generator"]
          __A	:       Tuple      =							inputs["num_inference_steps"]
          __A	:       str      =							inputs["output_type"]

          # inputs with prompt converted to embeddings
          __A	:       Dict      =							{
              "prompt_embeds": prompt_embeds,
              "negative_prompt_embeds": negative_prompt_embeds,
              "generator": generator,
              "num_inference_steps": num_inference_steps,
              "output_type": output_type,
          }

          if image is not None:
               __A	:       Dict      =							image

          if mask_image is not None:
               __A	:       List[str]      =							mask_image

          if original_image is not None:
               __A	:       Optional[int]      =							original_image

          __A	:       str      =							pipe_loaded(**lowerCamelCase		)[0]

          __A	:       List[Any]      =							np.abs(to_np(lowerCamelCase		) - to_np(lowerCamelCase		)		).max()
          self.assertLess(lowerCamelCase			,     1E-4		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       int      =							self.get_dummy_components()
          __A	:       Optional[Any]      =							self.pipeline_class(**lowerCamelCase		)
          pipe.to(lowerCamelCase		)
          pipe.set_progress_bar_config(disable=lowerCamelCase		)

          __A	:       Optional[int]      =							self.get_dummy_inputs(lowerCamelCase		)
          __A	:       List[str]      =							pipe(**lowerCamelCase		)[0]

          with tempfile.TemporaryDirectory() as tmpdir:
               pipe.save_pretrained(lowerCamelCase		)
               __A	:       List[str]      =							self.pipeline_class.from_pretrained(lowerCamelCase		)
               pipe_loaded.to(lowerCamelCase		)
               pipe_loaded.set_progress_bar_config(disable=lowerCamelCase		)

          pipe_loaded.unet.set_attn_processor(AttnAddedKVProcessor()		)  # For reproducibility tests

          __A	:       Dict      =							self.get_dummy_inputs(lowerCamelCase		)
          __A	:       Optional[Any]      =							pipe_loaded(**lowerCamelCase		)[0]

          __A	:       str      =							np.abs(to_np(lowerCamelCase		) - to_np(lowerCamelCase		)		).max()
          self.assertLess(lowerCamelCase			,     1E-4		)





'''simple docstring'''


import unittest

from transformers import XLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import (
          XLMForMultipleChoice,
          XLMForQuestionAnswering,
          XLMForQuestionAnsweringSimple,
          XLMForSequenceClassification,
          XLMForTokenClassification,
          XLMModel,
          XLMWithLMHeadModel,
      )
      from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST







class 							__magic_name__	:

     """simple docstring"""






     def __init__(   self			,     lowerCamelCase			,     lowerCamelCase=13			,     lowerCamelCase=7			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=True			,     lowerCamelCase=False			,     lowerCamelCase=False			,     lowerCamelCase=False			,     lowerCamelCase=2			,     lowerCamelCase=99			,     lowerCamelCase=0			,     lowerCamelCase=32			,     lowerCamelCase=5			,     lowerCamelCase=4			,     lowerCamelCase=0.1			,     lowerCamelCase=0.1			,     lowerCamelCase=512			,     lowerCamelCase=2			,     lowerCamelCase=0.02			,     lowerCamelCase=2			,     lowerCamelCase=4			,     lowerCamelCase="last"			,     lowerCamelCase=True			,     lowerCamelCase=None			,     lowerCamelCase=0			,     ):


          '''simple docstring'''





          __A	:       Tuple      =							parent
          __A	:       Optional[Any]      =							batch_size
          __A	:       int      =							seq_length
          __A	:       int      =							is_training
          __A	:       List[str]      =							use_input_lengths
          __A	:       Optional[Any]      =							use_token_type_ids
          __A	:       Any      =							use_labels
          __A	:       Dict      =							gelu_activation
          __A	:       List[str]      =							sinusoidal_embeddings
          __A	:       List[Any]      =							causal
          __A	:       Optional[int]      =							asm
          __A	:       List[Any]      =							n_langs
          __A	:       List[str]      =							vocab_size
          __A	:       Any      =							n_special
          __A	:       Optional[int]      =							hidden_size
          __A	:       Optional[Any]      =							num_hidden_layers
          __A	:       Tuple      =							num_attention_heads
          __A	:       List[str]      =							hidden_dropout_prob
          __A	:       Any      =							attention_probs_dropout_prob
          __A	:       Dict      =							max_position_embeddings
          __A	:       Optional[int]      =							type_sequence_label_size
          __A	:       Tuple      =							initializer_range
          __A	:       List[Any]      =							num_labels
          __A	:       List[Any]      =							num_choices
          __A	:       Any      =							summary_type
          __A	:       List[str]      =							use_proj
          __A	:       List[Any]      =							scope
          __A	:       str      =							bos_token_id


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       int      =							ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size		)
          __A	:       int      =							random_attention_mask([self.batch_size, self.seq_length]		)

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

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

          __A	:       int      =							None
          __A	:       Any      =							None
          __A	:       Tuple      =							None
          if self.use_labels:
               __A	:       List[Any]      =							ids_tensor([self.batch_size]			,     self.type_sequence_label_size		)
               __A	:       Optional[Any]      =							ids_tensor([self.batch_size, self.seq_length]			,     self.num_labels		)
               __A	:       int      =							ids_tensor([self.batch_size]			,     2		).float()
               __A	:       List[str]      =							ids_tensor([self.batch_size]			,     self.num_choices		)

          __A	:       List[Any]      =							self.get_config()

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


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          return 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			,     num_labels=self.num_labels			,     bos_token_id=self.bos_token_id			,     )


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Tuple      =							XLMModel(config=lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()
          __A	:       Tuple      =							model(lowerCamelCase			,     lengths=lowerCamelCase			,     langs=lowerCamelCase		)
          __A	:       Dict      =							model(lowerCamelCase			,     langs=lowerCamelCase		)
          __A	:       List[Any]      =							model(lowerCamelCase		)
          self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       str      =							XLMWithLMHeadModel(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       List[str]      =							model(lowerCamelCase			,     token_type_ids=lowerCamelCase			,     labels=lowerCamelCase		)
          self.parent.assertEqual(result.loss.shape			,     ()		)
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       str      =							XLMForQuestionAnsweringSimple(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       int      =							model(lowerCamelCase		)

          __A	:       List[str]      =							model(lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase		)
          __A	:       List[Any]      =							outputs
          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 lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Optional[Any]      =							XLMForQuestionAnswering(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       str      =							model(lowerCamelCase		)

          __A	:       Optional[int]      =							model(
              lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase			,     cls_index=lowerCamelCase			,     is_impossible=lowerCamelCase			,     p_mask=lowerCamelCase			,     )

          __A	:       Any      =							model(
              lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase			,     cls_index=lowerCamelCase			,     is_impossible=lowerCamelCase			,     )

          ((__A)  ,)	:       List[str]      =							result_with_labels.to_tuple()

          __A	:       int      =							model(lowerCamelCase			,     start_positions=lowerCamelCase			,     end_positions=lowerCamelCase		)

          ((__A)  ,)	:       List[Any]      =							result_with_labels.to_tuple()

          self.parent.assertEqual(result_with_labels.loss.shape			,     ()		)
          self.parent.assertEqual(result.start_top_log_probs.shape			,     (self.batch_size, model.config.start_n_top)		)
          self.parent.assertEqual(result.start_top_index.shape			,     (self.batch_size, model.config.start_n_top)		)
          self.parent.assertEqual(
              result.end_top_log_probs.shape			,     (self.batch_size, model.config.start_n_top * model.config.end_n_top)		)
          self.parent.assertEqual(
              result.end_top_index.shape			,     (self.batch_size, model.config.start_n_top * model.config.end_n_top)		)
          self.parent.assertEqual(result.cls_logits.shape			,     (self.batch_size,)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Optional[int]      =							XLMForSequenceClassification(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       str      =							model(lowerCamelCase		)
          __A	:       Optional[int]      =							model(lowerCamelCase			,     labels=lowerCamelCase		)
          self.parent.assertEqual(result.loss.shape			,     ()		)
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.type_sequence_label_size)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       str      =							self.num_labels
          __A	:       int      =							XLMForTokenClassification(lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()

          __A	:       str      =							model(lowerCamelCase			,     attention_mask=lowerCamelCase			,     labels=lowerCamelCase		)
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.num_labels)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Union[str, Any]      =							self.num_choices
          __A	:       Union[str, Any]      =							XLMForMultipleChoice(config=lowerCamelCase		)
          model.to(lowerCamelCase		)
          model.eval()
          __A	:       Union[str, Any]      =							input_ids.unsqueeze(1		).expand(-1			,     self.num_choices			,     -1		).contiguous()
          __A	:       Optional[int]      =							token_type_ids.unsqueeze(1		).expand(-1			,     self.num_choices			,     -1		).contiguous()
          __A	:       Tuple      =							input_mask.unsqueeze(1		).expand(-1			,     self.num_choices			,     -1		).contiguous()
          __A	:       Any      =							model(
              lowerCamelCase			,     attention_mask=lowerCamelCase			,     token_type_ids=lowerCamelCase			,     labels=lowerCamelCase			,     )
          self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_choices)		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       List[Any]      =							self.prepare_config_and_inputs()
          (
              (
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,(
              __A
          )  ,
          )	:       str      =							config_and_inputs
          __A	:       int      =							{"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
          return config, inputs_dict







@require_torch
class 							__magic_name__	(       lowerCAmelCase    ,		lowerCAmelCase    ,		lowerCAmelCase    ,		unittest.TestCase ):

     """simple docstring"""






     lowerCamelCase__       						=				(
         (
             XLMModel,
             XLMWithLMHeadModel,
             XLMForQuestionAnswering,
             XLMForSequenceClassification,
             XLMForQuestionAnsweringSimple,
             XLMForTokenClassification,
             XLMForMultipleChoice,
         )
         if is_torch_available()
         else ()
     )
     lowerCamelCase__       						=				(
         (XLMWithLMHeadModel,) if is_torch_available() else ()
     )  # TODO (PVP): Check other models whether language generation is also applicable
     lowerCamelCase__       						=				(
         {
             'feature-extraction': XLMModel,
             'fill-mask': XLMWithLMHeadModel,
             'question-answering': XLMForQuestionAnsweringSimple,
             'text-classification': XLMForSequenceClassification,
             'text-generation': XLMWithLMHeadModel,
             'token-classification': XLMForTokenClassification,
             'zero-shot': XLMForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase		):


          '''simple docstring'''





          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 lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=False		):


          '''simple docstring'''





          __A	:       Optional[Any]      =							super()._prepare_for_class(lowerCamelCase			,     lowerCamelCase			,     return_labels=lowerCamelCase		)

          if return_labels:
               if model_class.__name__ == "XLMForQuestionAnswering":
                    __A	:       List[Any]      =							torch.zeros(
                        self.model_tester.batch_size			,     dtype=torch.long			,     device=lowerCamelCase		)
                    __A	:       Tuple      =							torch.zeros(
                        self.model_tester.batch_size			,     dtype=torch.long			,     device=lowerCamelCase		)

          return inputs_dict


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[int]      =							XLMModelTester(self		)
          __A	:       Any      =							ConfigTester(self			,     config_class=lowerCamelCase			,     emb_dim=37		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          self.config_tester.run_common_tests()


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[int]      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_model(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Dict      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_lm_head(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Any      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_simple_qa(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       int      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_qa(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Tuple      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_sequence_classif(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Optional[int]      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_token_classif(*lowerCamelCase		)


     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       List[Any]      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCamelCase		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=False			,     lowerCamelCase=1		):


          '''simple docstring'''





          self.assertIsInstance(lowerCamelCase			,     lowerCamelCase		)
          self.assertListEqual(
              [isinstance(lowerCamelCase			,     lowerCamelCase		) for iter_attentions in attentions]			,     [True] * len(lowerCamelCase		)		)
          self.assertEqual(len(lowerCamelCase		)			,     (max_length - min_length) * num_beam_groups		)

          for idx, iter_attentions in enumerate(lowerCamelCase		):
               # adds PAD dummy token
               __A	:       Optional[Any]      =							min_length + idx + 1
               __A	:       Optional[int]      =							min_length + idx + 1

               __A	:       List[Any]      =							(
                   batch_size * num_beam_groups,
                   config.num_attention_heads,
                   tgt_len,
                   src_len,
               )
               # check attn size
               self.assertListEqual(
                   [layer_attention.shape for layer_attention in iter_attentions]			,     [expected_shape] * len(lowerCamelCase		)		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase=False			,     lowerCamelCase=1		):


          '''simple docstring'''





          self.assertIsInstance(lowerCamelCase			,     lowerCamelCase		)
          self.assertListEqual(
              [isinstance(lowerCamelCase			,     lowerCamelCase		) for iter_hidden_states in hidden_states]			,     [True] * len(lowerCamelCase		)			,     )
          self.assertEqual(len(lowerCamelCase		)			,     (max_length - min_length) * num_beam_groups		)

          for idx, iter_hidden_states in enumerate(lowerCamelCase		):
               # adds PAD dummy token
               __A	:       Dict      =							min_length + idx + 1
               __A	:       Union[str, Any]      =							(batch_size * num_beam_groups, seq_len, config.hidden_size)
               # check hidden size
               self.assertListEqual(
                   [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]			,     [expected_shape] * len(lowerCamelCase		)			,     )
          pass


     @slow
     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __A	:       Any      =							XLMModel.from_pretrained(lowerCamelCase		)
               self.assertIsNotNone(lowerCamelCase		)







@require_torch
class 							__magic_name__	(       unittest.TestCase ):

     """simple docstring"""






     @slow
     def lowerCAmelCase__  (   self		):


          '''simple docstring'''





          __A	:       Tuple      =							XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"		)
          model.to(lowerCamelCase		)
          __A	:       Optional[int]      =							torch.tensor([[14, 447]]			,     dtype=torch.long			,     device=lowerCamelCase		)  # the president
          __A	:       Optional[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
          __A	:       Union[str, Any]      =							model.generate(lowerCamelCase			,     do_sample=lowerCamelCase		)
          self.assertListEqual(output_ids[0].cpu().numpy().tolist()			,     lowerCamelCase		)

