


"""simple docstring"""



import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

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

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


UpperCAmelCase      		=			1E-4

if is_torch_available():
 import torch

 from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
 from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder
@require_torch
class 					__magic_name__		:






       def __init__(   self  :    List[Any]  ,     snake_case__  :    int  ,     snake_case__  :    Any=1_6  ,     snake_case__  :    Tuple=1_3  ,     snake_case__  :    Any=7  ,     snake_case__  :    int=1_4  ,     snake_case__  :    str=1_0  ,     snake_case__  :    Tuple=1_9  ,     snake_case__  :    Dict=5  ,     snake_case__  :    Optional[Any]=4  ,     snake_case__  :    Tuple=True  ,     snake_case__  :    Any=1_6  ,     snake_case__  :    List[str]=2  ,     snake_case__  :    Any=4  ,     snake_case__  :    Dict=4  ,     snake_case__  :    Optional[int]="gelu"  ,     snake_case__  :    Tuple=0.1  ,     snake_case__  :    Any=0.1  ,     snake_case__  :    Optional[Any]=[1, 2, 3, 4, 5]  ,     snake_case__  :    List[str]=2_5  ,     snake_case__  :    Optional[int]=5  ,     ):

              '''simple docstring'''






              lowercase		:List[str]       							=				d_model
              lowercase		:Optional[int]       							=				parent
              lowercase		:int       							=				batch_size
              lowercase		:Union[str, Any]       							=				prediction_length
              lowercase		:Union[str, Any]       							=				context_length
              lowercase		:Union[str, Any]       							=				cardinality
              lowercase		:str       							=				num_time_features
              lowercase		:Dict       							=				lags_sequence
              lowercase		:int       							=				embedding_dimension
              lowercase		:List[str]       							=				is_training
              lowercase		:Union[str, Any]       							=				hidden_size
              lowercase		:Optional[Any]       							=				num_hidden_layers
              lowercase		:int       							=				num_attention_heads
              lowercase		:Dict       							=				intermediate_size
              lowercase		:str       							=				hidden_act
              lowercase		:List[Any]       							=				hidden_dropout_prob
              lowercase		:Dict       							=				attention_probs_dropout_prob

              lowercase		:Union[str, Any]       							=				context_length
              lowercase		:Any       							=				prediction_length + label_length
              lowercase		:Any       							=				label_length

              lowercase		:str       							=				moving_average
              lowercase		:Optional[Any]       							=				autocorrelation_factor






       def  __snake_case						(   self  :    str				):

              '''simple docstring'''






              return AutoformerConfig(
                  d_model=self.d_model  ,     encoder_layers=self.num_hidden_layers  ,     decoder_layers=self.num_hidden_layers  ,     encoder_attention_heads=self.num_attention_heads  ,     decoder_attention_heads=self.num_attention_heads  ,     encoder_ffn_dim=self.intermediate_size  ,     decoder_ffn_dim=self.intermediate_size  ,     dropout=self.hidden_dropout_prob  ,     attention_dropout=self.attention_probs_dropout_prob  ,     prediction_length=self.prediction_length  ,     context_length=self.context_length  ,     label_length=self.label_length  ,     lags_sequence=self.lags_sequence  ,     num_time_features=self.num_time_features  ,     num_static_categorical_features=1  ,     cardinality=[self.cardinality]  ,     embedding_dimension=[self.embedding_dimension]  ,     moving_average=self.moving_average  ,     )






       def  __snake_case						(   self  :    Any  ,     snake_case__  :    str				):

              '''simple docstring'''






              lowercase		:Tuple       							=				config.context_length + max(config.lags_sequence				)

              lowercase		:Optional[Any]       							=				ids_tensor([self.batch_size, 1]  ,     config.cardinality[0]				)
              lowercase		:Union[str, Any]       							=				floats_tensor([self.batch_size, _past_length, config.num_time_features]				)
              lowercase		:Optional[Any]       							=				floats_tensor([self.batch_size, _past_length]				)
              lowercase		:Dict       							=				floats_tensor([self.batch_size, _past_length]				) > 0.5

              # decoder inputs
              lowercase		:Union[str, Any]       							=				floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]				)
              lowercase		:List[str]       							=				floats_tensor([self.batch_size, config.prediction_length]				)

              lowercase		:List[str]       							=				{
                  '''past_values''': past_values,
                  '''static_categorical_features''': static_categorical_features,
                  '''past_time_features''': past_time_features,
                  '''past_observed_mask''': past_observed_mask,
                  '''future_time_features''': future_time_features,
                  '''future_values''': future_values,
              }
              return inputs_dict






       def  __snake_case						(   self  :    Tuple				):

              '''simple docstring'''






              lowercase		:str       							=				self.get_config()
              lowercase		:Tuple       							=				self.prepare_autoformer_inputs_dict(snake_case__				)
              return config, inputs_dict






       def  __snake_case						(   self  :    str				):

              '''simple docstring'''






              lowercase							,  lowercase		:Dict       							=				self.prepare_config_and_inputs()
              return config, inputs_dict







       def  __snake_case						(   self  :    List[Any]  ,     snake_case__  :    Union[str, Any]  ,     snake_case__  :    Any				):

              '''simple docstring'''






              lowercase		:Any       							=				AutoformerModel(config=snake_case__				).to(snake_case__				).eval()
              lowercase		:Union[str, Any]       							=				model(**snake_case__				)

              lowercase		:List[str]       							=				outputs.encoder_last_hidden_state
              lowercase		:Optional[int]       							=				outputs.last_hidden_state

              with tempfile.TemporaryDirectory() as tmpdirname:
                     lowercase		:Optional[int]       							=				model.get_encoder()
                     encoder.save_pretrained(snake_case__				)
                     lowercase		:Optional[Any]       							=				AutoformerEncoder.from_pretrained(snake_case__				).to(snake_case__				)

              lowercase							,  lowercase							,  lowercase							,  lowercase							,  lowercase		:Optional[Any]       							=				model.create_network_inputs(**snake_case__				)
              lowercase							,  lowercase		:Tuple       							=				model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]				)

              lowercase		:int       							=				torch.cat(
                  (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])  ,     dim=-1  ,     )
              lowercase		:Optional[Any]       							=				encoder(inputs_embeds=snake_case__				)[0]
              self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3				)

              lowercase		:Optional[Any]       							=				(
                  torch.mean(transformer_inputs[:, : config.context_length, ...]  ,     dim=1				)
                  .unsqueeze(1				)
                  .repeat(1  ,     config.prediction_length  ,     1				)
              )
              lowercase		:List[Any]       							=				torch.zeros(
                  [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]  ,     device=enc_input.device  ,     )

              lowercase		:str       							=				torch.cat(
                  (
                      torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)  ,     dim=1				),
                      feature[:, config.context_length - config.label_length :, ...],
                  )  ,     dim=-1  ,     )
              lowercase		:Tuple       							=				torch.cat(
                  (
                      torch.cat((trend_input[:, -config.label_length :, ...], mean)  ,     dim=1				),
                      feature[:, config.context_length - config.label_length :, ...],
                  )  ,     dim=-1  ,     )

              with tempfile.TemporaryDirectory() as tmpdirname:
                     lowercase		:str       							=				model.get_decoder()
                     decoder.save_pretrained(snake_case__				)
                     lowercase		:Optional[int]       							=				AutoformerDecoder.from_pretrained(snake_case__				).to(snake_case__				)

              lowercase		:Union[str, Any]       							=				decoder(
                  trend=snake_case__  ,     inputs_embeds=snake_case__  ,     encoder_hidden_states=snake_case__  ,     )[0]

              self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3				)







@require_torch
class 					__magic_name__		(			__UpperCAmelCase			,						__UpperCAmelCase			,						unittest.TestCase     ):
       __A			:      List[Any]        =   (AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
       __A			:      Dict        =   (AutoformerForPrediction,) if is_torch_available() else ()
       __A			:      str        =   {"feature-extraction": AutoformerModel} if is_torch_available() else {}
       __A			:      Optional[int]        =   False
       __A			:      List[str]        =   False
       __A			:      List[Any]        =   False
       __A			:      List[str]        =   False
       __A			:      List[str]        =   False
       __A			:      List[str]        =   False






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase		:Union[str, Any]       							=				AutoformerModelTester(self				)
              lowercase		:List[str]       							=				ConfigTester(self  ,     config_class=snake_case__  ,     has_text_modality=snake_case__				)






       def  __snake_case						(   self  :    Dict				):

              '''simple docstring'''






              self.config_tester.run_common_tests()






       def  __snake_case						(   self  :    Tuple				):

              '''simple docstring'''






              lowercase							,  lowercase		:str       							=				self.model_tester.prepare_config_and_inputs()
              for model_class in self.all_model_classes:
                     lowercase		:Any       							=				model_class(snake_case__				)

                     with tempfile.TemporaryDirectory() as tmpdirname:
                            model.save_pretrained(snake_case__				)
                            lowercase							,  lowercase		:Optional[int]       							=				model_class.from_pretrained(snake_case__  ,     output_loading_info=snake_case__				)
                     self.assertEqual(info['''missing_keys''']  ,     []				)






       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:Union[str, Any]       							=				self.model_tester.prepare_config_and_inputs_for_common()
              self.model_tester.check_encoder_decoder_model_standalone(*snake_case__				)






       @unittest.skip(reason='''Model has no tokens embeddings'''				)
       def  __snake_case						(   self  :    List[str]				):

              '''simple docstring'''






              pass






       def  __snake_case						(   self  :    Union[str, Any]				):

              '''simple docstring'''






              lowercase		:Dict       							=				inspect.signature(getattr(snake_case__  ,     '''forward'''				)				)
              # The main input is the name of the argument after `self`
              lowercase		:List[Any]       							=				list(model_signature.parameters.keys()				)[1]
              self.assertEqual(AutoformerModel.main_input_name  ,     snake_case__				)






       def  __snake_case						(   self  :    List[str]				):

              '''simple docstring'''






              lowercase							,  lowercase		:Union[str, Any]       							=				self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     lowercase		:List[Any]       							=				model_class(snake_case__				)
                     lowercase		:Dict       							=				inspect.signature(model.forward				)
                     # signature.parameters is an OrderedDict => so arg_names order is deterministic
                     lowercase		:Any       							=				[*signature.parameters.keys()]

                     lowercase		:str       							=				[
                         '''past_values''',
                         '''past_time_features''',
                         '''past_observed_mask''',
                         '''static_categorical_features''',
                         '''static_real_features''',
                         '''future_values''',
                         '''future_time_features''',
                     ]

                     if model.__class__.__name__ in ["AutoformerForPrediction"]:
                            expected_arg_names.append('''future_observed_mask'''				)

                     expected_arg_names.extend(
                         [
                             '''decoder_attention_mask''',
                             '''head_mask''',
                             '''decoder_head_mask''',
                             '''cross_attn_head_mask''',
                             '''encoder_outputs''',
                             '''past_key_values''',
                             '''output_hidden_states''',
                             '''output_attentions''',
                             '''use_cache''',
                             '''return_dict''',
                         ]				)

                     self.assertListEqual(arg_names[: len(snake_case__				)]  ,     snake_case__				)






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase							,  lowercase		:Union[str, Any]       							=				self.model_tester.prepare_config_and_inputs_for_common()
              lowercase		:List[str]       							=				True

              lowercase		:Optional[Any]       							=				getattr(self.model_tester  ,     '''seq_length'''  ,     snake_case__				)
              lowercase		:Tuple       							=				getattr(self.model_tester  ,     '''decoder_seq_length'''  ,     snake_case__				)
              lowercase		:Optional[int]       							=				getattr(self.model_tester  ,     '''encoder_seq_length'''  ,     snake_case__				)
              lowercase		:Optional[Any]       							=				getattr(self.model_tester  ,     '''d_model'''  ,     snake_case__				)
              lowercase		:Optional[Any]       							=				getattr(self.model_tester  ,     '''num_attention_heads'''  ,     snake_case__				)
              lowercase		:Union[str, Any]       							=				d_model // num_attention_heads

              for model_class in self.all_model_classes:
                     lowercase		:Any       							=				True
                     lowercase		:Optional[int]       							=				False
                     lowercase		:int       							=				True
                     lowercase		:Tuple       							=				model_class(snake_case__				)
                     model.to(snake_case__				)
                     model.eval()
                     with torch.no_grad():
                            lowercase		:List[str]       							=				model(**self._prepare_for_class(snake_case__  ,     snake_case__				)				)
                     lowercase		:Any       							=				outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
                     self.assertEqual(len(snake_case__				)  ,     self.model_tester.num_hidden_layers				)

                     # check that output_attentions also work using config
                     del inputs_dict["output_attentions"]
                     lowercase		:Optional[Any]       							=				True
                     lowercase		:Any       							=				model_class(snake_case__				)
                     model.to(snake_case__				)
                     model.eval()
                     with torch.no_grad():
                            lowercase		:Any       							=				model(**self._prepare_for_class(snake_case__  ,     snake_case__				)				)
                     lowercase		:Optional[int]       							=				outputs.encoder_attentions
                     self.assertEqual(len(snake_case__				)  ,     self.model_tester.num_hidden_layers				)

                     self.assertListEqual(
                         list(attentions[0].shape[-3:]				)  ,     [self.model_tester.num_attention_heads, encoder_seq_length, dim]  ,     )
                     lowercase		:Dict       							=				len(snake_case__				)

                     lowercase		:List[str]       							=				7

                     if "last_hidden_state" in outputs:
                            correct_outlen += 1

                     if "trend" in outputs:
                            correct_outlen += 1

                     if "past_key_values" in outputs:
                            correct_outlen += 1  # past_key_values have been returned

                     if "loss" in outputs:
                            correct_outlen += 1

                     if "params" in outputs:
                            correct_outlen += 1

                     self.assertEqual(snake_case__  ,     snake_case__				)

                     # decoder attentions
                     lowercase		:Optional[int]       							=				outputs.decoder_attentions
                     self.assertIsInstance(snake_case__  ,     (list, tuple)				)
                     self.assertEqual(len(snake_case__				)  ,     self.model_tester.num_hidden_layers				)
                     self.assertListEqual(
                         list(decoder_attentions[0].shape[-3:]				)  ,     [self.model_tester.num_attention_heads, decoder_seq_length, dim]  ,     )

                     # cross attentions
                     lowercase		:str       							=				outputs.cross_attentions
                     self.assertIsInstance(snake_case__  ,     (list, tuple)				)
                     self.assertEqual(len(snake_case__				)  ,     self.model_tester.num_hidden_layers				)
                     self.assertListEqual(
                         list(cross_attentions[0].shape[-3:]				)  ,     [self.model_tester.num_attention_heads, decoder_seq_length, dim]  ,     )

              # Check attention is always last and order is fine
              lowercase		:Union[str, Any]       							=				True
              lowercase		:Tuple       							=				True
              lowercase		:str       							=				model_class(snake_case__				)
              model.to(snake_case__				)
              model.eval()
              with torch.no_grad():
                     lowercase		:Any       							=				model(**self._prepare_for_class(snake_case__  ,     snake_case__				)				)

              self.assertEqual(out_len + 2  ,     len(snake_case__				)				)

              lowercase		:Any       							=				outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

              self.assertEqual(len(snake_case__				)  ,     self.model_tester.num_hidden_layers				)
              self.assertListEqual(
                  list(self_attentions[0].shape[-3:]				)  ,     [self.model_tester.num_attention_heads, encoder_seq_length, dim]  ,     )







       @is_flaky()
       def  __snake_case						(   self  :    List[Any]				):

              '''simple docstring'''






              super().test_retain_grad_hidden_states_attentions()







def       lowerCamelCase					(a_						:Optional[Any]="train-batch.pt")     ->							Any:
       lowercase		:List[Any]       							=				hf_hub_download(repo_id='''hf-internal-testing/tourism-monthly-batch'''				,				filename=a_				,				repo_type='''dataset''')
       lowercase		:Tuple       							=				torch.load(a_				,				map_location=a_)
       return batch




@require_torch
@slow
class 					__magic_name__		(			unittest.TestCase     ):






       def  __snake_case						(   self  :    Dict				):

              '''simple docstring'''






              lowercase		:Any       							=				AutoformerModel.from_pretrained('''huggingface/autoformer-tourism-monthly'''				).to(snake_case__				)
              lowercase		:Optional[Any]       							=				prepare_batch()

              with torch.no_grad():
                     lowercase		:Any       							=				model(
                         past_values=batch['''past_values''']  ,     past_time_features=batch['''past_time_features''']  ,     past_observed_mask=batch['''past_observed_mask''']  ,     static_categorical_features=batch['''static_categorical_features''']  ,     future_values=batch['''future_values''']  ,     future_time_features=batch['''future_time_features''']  ,     )[0]

              lowercase		:Optional[Any]       							=				torch.Size(
                  (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size)				)
              self.assertEqual(output.shape  ,     snake_case__				)

              lowercase		:List[str]       							=				torch.tensor(
                  [[0.35_93, -1.33_98, 0.63_30], [0.22_79, 1.53_96, -0.17_92], [0.04_50, 1.32_25, -0.23_35]]  ,     device=snake_case__				)
              self.assertTrue(torch.allclose(output[0, :3, :3]  ,     snake_case__  ,     atol=snake_case__				)				)






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase		:str       							=				AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''				).to(snake_case__				)
              lowercase		:Tuple       							=				prepare_batch('''val-batch.pt'''				)
              with torch.no_grad():
                     lowercase		:int       							=				model(
                         past_values=batch['''past_values''']  ,     past_time_features=batch['''past_time_features''']  ,     past_observed_mask=batch['''past_observed_mask''']  ,     static_categorical_features=batch['''static_categorical_features''']  ,     ).encoder_last_hidden_state
              lowercase		:str       							=				torch.Size((6_4, model.config.context_length, model.config.d_model)				)
              self.assertEqual(output.shape  ,     snake_case__				)

              lowercase		:str       							=				torch.tensor(
                  [[-0.07_34, -0.90_36, 0.83_58], [4.71_86, 2.41_13, 1.95_81], [1.79_53, 2.35_58, 1.29_70]]  ,     device=snake_case__				)
              self.assertTrue(torch.allclose(output[0, :3, :3]  ,     snake_case__  ,     atol=snake_case__				)				)







       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:Optional[int]       							=				AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''				).to(snake_case__				)
              lowercase		:Tuple       							=				prepare_batch('''val-batch.pt'''				)
              with torch.no_grad():
                     lowercase		:Tuple       							=				model.generate(
                         static_categorical_features=batch['''static_categorical_features''']  ,     past_time_features=batch['''past_time_features''']  ,     past_values=batch['''past_values''']  ,     future_time_features=batch['''future_time_features''']  ,     past_observed_mask=batch['''past_observed_mask''']  ,     )
              lowercase		:int       							=				torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length)				)
              self.assertEqual(outputs.sequences.shape  ,     snake_case__				)

              lowercase		:int       							=				torch.tensor([31_30.67_63, 40_56.52_93, 70_53.07_86]  ,     device=snake_case__				)
              lowercase		:Any       							=				outputs.sequences.mean(dim=1				)
              self.assertTrue(torch.allclose(mean_prediction[0, -3:]  ,     snake_case__  ,     rtol=1e-1				)				)





"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase      		=			{
    '''configuration_xlm_roberta''': [
        '''XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''XLMRobertaConfig''',
        '''XLMRobertaOnnxConfig''',
    ],
}

try:
 if not is_sentencepiece_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=			['''XLMRobertaTokenizer''']

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=			['''XLMRobertaTokenizerFast''']

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=			[
     '''XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''XLMRobertaForCausalLM''',
     '''XLMRobertaForMaskedLM''',
     '''XLMRobertaForMultipleChoice''',
     '''XLMRobertaForQuestionAnswering''',
     '''XLMRobertaForSequenceClassification''',
     '''XLMRobertaForTokenClassification''',
     '''XLMRobertaModel''',
     '''XLMRobertaPreTrainedModel''',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=			[
     '''TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''TFXLMRobertaForCausalLM''',
     '''TFXLMRobertaForMaskedLM''',
     '''TFXLMRobertaForMultipleChoice''',
     '''TFXLMRobertaForQuestionAnswering''',
     '''TFXLMRobertaForSequenceClassification''',
     '''TFXLMRobertaForTokenClassification''',
     '''TFXLMRobertaModel''',
     '''TFXLMRobertaPreTrainedModel''',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 UpperCAmelCase      		=			[
     '''FLAX_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''FlaxXLMRobertaForMaskedLM''',
     '''FlaxXLMRobertaForCausalLM''',
     '''FlaxXLMRobertaForMultipleChoice''',
     '''FlaxXLMRobertaForQuestionAnswering''',
     '''FlaxXLMRobertaForSequenceClassification''',
     '''FlaxXLMRobertaForTokenClassification''',
     '''FlaxXLMRobertaModel''',
     '''FlaxXLMRobertaPreTrainedModel''',
 ]

if TYPE_CHECKING:
 from .configuration_xlm_roberta import (
     XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP,
     XLMRobertaConfig,
     XLMRobertaOnnxConfig,
 )

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_xlm_roberta import XLMRobertaTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_xlm_roberta_fast import XLMRobertaTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_xlm_roberta import (
      XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
      XLMRobertaForCausalLM,
      XLMRobertaForMaskedLM,
      XLMRobertaForMultipleChoice,
      XLMRobertaForQuestionAnswering,
      XLMRobertaForSequenceClassification,
      XLMRobertaForTokenClassification,
      XLMRobertaModel,
      XLMRobertaPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_xlm_roberta import (
      TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFXLMRobertaForCausalLM,
      TFXLMRobertaForMaskedLM,
      TFXLMRobertaForMultipleChoice,
      TFXLMRobertaForQuestionAnswering,
      TFXLMRobertaForSequenceClassification,
      TFXLMRobertaForTokenClassification,
      TFXLMRobertaModel,
      TFXLMRobertaPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_xlm_roberta import (
      FLAX_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
      FlaxXLMRobertaForCausalLM,
      FlaxXLMRobertaForMaskedLM,
      FlaxXLMRobertaForMultipleChoice,
      FlaxXLMRobertaForQuestionAnswering,
      FlaxXLMRobertaForSequenceClassification,
      FlaxXLMRobertaForTokenClassification,
      FlaxXLMRobertaModel,
      FlaxXLMRobertaPreTrainedModel,
  )

else:
 import sys

 UpperCAmelCase      		=			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

