

import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
       from transformers import SpeechaTextFeatureExtractor

lowerCamelCase           =					random.Random()




def 			UpperCAmelCase__				(			_A      : Optional[Any]	,      _A      : Any=1.0	,      _A      : List[Any]=None	,      _A      : str=None							):





  '''simple docstring'''







  if rng is None:
    a__  =global_rng

  a__  =[]
  for batch_idx in range(shape[0]							):
    values.append([]							)
    for _ in range(shape[1]							):
      values[-1].append(rng.random() * scale							)

  return values







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

   '''simple docstring'''




   def __init__(				self,    lowercase_,    lowercase_=7,    lowercase_=400,    lowercase_=2000,    lowercase_=24,    lowercase_=24,    lowercase_=0.0,    lowercase_=16000,    lowercase_=True,    lowercase_=True,    )							->    Union[str, Any]:






     """simple docstring"""






     a__  =parent
     a__  =batch_size
     a__  =min_seq_length
     a__  =max_seq_length
     a__  =(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
     a__  =feature_size
     a__  =num_mel_bins
     a__  =padding_value
     a__  =sampling_rate
     a__  =return_attention_mask
     a__  =do_normalize



   def  _UpperCAmelCase (				self       )							->    Optional[Any]:






     """simple docstring"""






     return {
         "feature_size": self.feature_size,
         "num_mel_bins": self.num_mel_bins,
         "padding_value": self.padding_value,
         "sampling_rate": self.sampling_rate,
         "return_attention_mask": self.return_attention_mask,
         "do_normalize": self.do_normalize,
     }



   def  _UpperCAmelCase (				self,    lowercase_=False,    lowercase_=False       )							->    Optional[Any]:






     """simple docstring"""






     def _flatten(lowercase_       ):
       return list(itertools.chain(*lowercase_       )       )

     if equal_length:
       a__  =[floats_list((self.max_seq_length, self.feature_size)       ) for _ in range(self.batch_size       )]
     else:
       # make sure that inputs increase in size
       a__  =[
           floats_list((x, self.feature_size)       )
           for x in range(self.min_seq_length,    self.max_seq_length,    self.seq_length_diff       )
       ]
     if numpify:
       a__  =[np.asarray(lowercase_       ) for x in speech_inputs]
     return speech_inputs







@require_torch
@require_torchaudio
class 						__magic_name__			(							lowerCamelCase__		,       unittest.TestCase							):

   '''simple docstring'''




   lowerCamelCase__ :	Optional[int]    =   SpeechaTextFeatureExtractor if is_speech_available() else None



   def  _UpperCAmelCase (				self       )							->    Dict:






     """simple docstring"""






     a__  =SpeechaTextFeatureExtractionTester(self       )



   def  _UpperCAmelCase (				self,    lowercase_       )							->    int:






     """simple docstring"""






     self.assertTrue(np.all(np.mean(lowercase_,    axis=0       ) < 1E-3       )       )
     self.assertTrue(np.all(np.abs(np.var(lowercase_,    axis=0       ) - 1       ) < 1E-3       )       )



   def  _UpperCAmelCase (				self       )							->    Optional[int]:






     """simple docstring"""






     a__  =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
     # create three inputs of length 800, 1000, and 1200
     a__  =[floats_list((1, x)       )[0] for x in range(800,    1400,    200       )]
     a__  =[np.asarray(lowercase_       ) for speech_input in speech_inputs]

     # Test feature size
     a__  =feature_extractor(lowercase_,    padding=lowercase_,    return_tensors='''np'''       ).input_features
     self.assertTrue(input_features.ndim == 3       )
     self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size       )

     # Test not batched input
     a__  =feature_extractor(speech_inputs[0],    return_tensors='''np'''       ).input_features
     a__  =feature_extractor(np_speech_inputs[0],    return_tensors='''np'''       ).input_features
     self.assertTrue(np.allclose(lowercase_,    lowercase_,    atol=1E-3       )       )

     # Test batched
     a__  =feature_extractor(lowercase_,    return_tensors='''np'''       ).input_features
     a__  =feature_extractor(lowercase_,    return_tensors='''np'''       ).input_features
     for enc_seq_a, enc_seq_a in zip(lowercase_,    lowercase_       ):
       self.assertTrue(np.allclose(lowercase_,    lowercase_,    atol=1E-3       )       )

     # Test 2-D numpy arrays are batched.
     a__  =[floats_list((1, x)       )[0] for x in (800, 800, 800)]
     a__  =np.asarray(lowercase_       )
     a__  =feature_extractor(lowercase_,    return_tensors='''np'''       ).input_features
     a__  =feature_extractor(lowercase_,    return_tensors='''np'''       ).input_features
     for enc_seq_a, enc_seq_a in zip(lowercase_,    lowercase_       ):
       self.assertTrue(np.allclose(lowercase_,    lowercase_,    atol=1E-3       )       )



   def  _UpperCAmelCase (				self       )							->    List[Any]:






     """simple docstring"""






     a__  =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
     a__  =[floats_list((1, x)       )[0] for x in range(800,    1400,    200       )]

     a__  =['''longest''', '''max_length''', '''do_not_pad''']
     a__  =[None, 16, None]
     for max_length, padding in zip(lowercase_,    lowercase_       ):
       a__  =feature_extractor(
           lowercase_,    padding=lowercase_,    max_length=lowercase_,    return_attention_mask=lowercase_       )
       a__  =inputs.input_features
       a__  =inputs.attention_mask
       a__  =[np.sum(lowercase_       ) for x in attention_mask]

       self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]       )
       self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]       )
       self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]       )



   def  _UpperCAmelCase (				self       )							->    str:






     """simple docstring"""






     a__  =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
     a__  =[floats_list((1, x)       )[0] for x in range(800,    1400,    200       )]

     a__  =['''longest''', '''max_length''', '''do_not_pad''']
     a__  =[None, 16, None]
     for max_length, padding in zip(lowercase_,    lowercase_       ):
       a__  =feature_extractor(
           lowercase_,    max_length=lowercase_,    padding=lowercase_,    return_tensors='''np''',    return_attention_mask=lowercase_       )
       a__  =inputs.input_features
       a__  =inputs.attention_mask
       a__  =[np.sum(lowercase_       ) for x in attention_mask]

       self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]       )
       self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6       )
       self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]       )
       self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6       )
       self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]       )



   def  _UpperCAmelCase (				self       )							->    Union[str, Any]:






     """simple docstring"""






     a__  =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
     a__  =[floats_list((1, x)       )[0] for x in range(800,    1400,    200       )]
     a__  =feature_extractor(
         lowercase_,    padding='''max_length''',    max_length=4,    truncation=lowercase_,    return_tensors='''np''',    return_attention_mask=lowercase_,    )
     a__  =inputs.input_features
     a__  =inputs.attention_mask
     a__  =np.sum(attention_mask == 1,    axis=1       )

     self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
     self._check_zero_mean_unit_variance(input_features[1]       )
     self._check_zero_mean_unit_variance(input_features[2]       )



   def  _UpperCAmelCase (				self       )							->    Dict:






     """simple docstring"""






     a__  =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
     a__  =[floats_list((1, x)       )[0] for x in range(800,    1400,    200       )]
     a__  =feature_extractor(
         lowercase_,    padding='''longest''',    max_length=4,    truncation=lowercase_,    return_tensors='''np''',    return_attention_mask=lowercase_,    )
     a__  =inputs.input_features
     a__  =inputs.attention_mask
     a__  =np.sum(attention_mask == 1,    axis=1       )

     self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
     self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]       )
     self._check_zero_mean_unit_variance(input_features[2]       )

     # make sure that if max_length < longest -> then pad to max_length
     self.assertEqual(input_features.shape,    (3, 4, 24)       )

     a__  =[floats_list((1, x)       )[0] for x in range(800,    1400,    200       )]
     a__  =feature_extractor(
         lowercase_,    padding='''longest''',    max_length=16,    truncation=lowercase_,    return_tensors='''np''',    return_attention_mask=lowercase_,    )
     a__  =inputs.input_features
     a__  =inputs.attention_mask
     a__  =np.sum(attention_mask == 1,    axis=1       )

     self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]       )
     self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]       )
     self._check_zero_mean_unit_variance(input_features[2]       )

     # make sure that if max_length < longest -> then pad to max_length
     self.assertEqual(input_features.shape,    (3, 6, 24)       )



   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






     import torch

     a__  =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
     a__  =np.random.rand(100,    32       ).astype(np.floataa       )
     a__  =np_speech_inputs.tolist()

     for inputs in [py_speech_inputs, np_speech_inputs]:
       a__  =feature_extractor.pad([{'''input_features''': inputs}],    return_tensors='''np'''       )
       self.assertTrue(np_processed.input_features.dtype == np.floataa       )
       a__  =feature_extractor.pad([{'''input_features''': inputs}],    return_tensors='''pt'''       )
       self.assertTrue(pt_processed.input_features.dtype == torch.floataa       )



   def  _UpperCAmelCase (				self,    lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     from datasets import load_dataset

     a__  =load_dataset('''hf-internal-testing/librispeech_asr_dummy''',    '''clean''',    split='''validation'''       )
     # automatic decoding with librispeech
     a__  =ds.sort('''id'''       ).select(range(lowercase_       )       )[:num_samples]['''audio''']

     return [x["array"] for x in speech_samples]



   def  _UpperCAmelCase (				self       )							->    Dict:






     """simple docstring"""






     a__  =np.array([
         -1.5745, -1.7713, -1.7020, -1.6069, -1.2250, -1.1105, -0.9072, -0.8241,
         -1.2310, -0.8098, -0.3320, -0.4101, -0.7985, -0.4996, -0.8213, -0.9128,
         -1.0420, -1.1286, -1.0440, -0.7999, -0.8405, -1.2275, -1.5443, -1.4625,
     ]       )
     # fmt: on

     a__  =self._load_datasamples(1       )
     a__  =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
     a__  =feature_extractor(lowercase_,    return_tensors='''pt'''       ).input_features
     self.assertEquals(input_features.shape,    (1, 584, 24)       )
     self.assertTrue(np.allclose(input_features[0, 0, :30],    lowercase_,    atol=1E-4       )       )



import os
import tempfile
import unittest

from transformers import FlaubertConfig, is_torch_available
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

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 (
           FlaubertForMultipleChoice,
           FlaubertForQuestionAnswering,
           FlaubertForQuestionAnsweringSimple,
           FlaubertForSequenceClassification,
           FlaubertForTokenClassification,
           FlaubertModel,
           FlaubertWithLMHeadModel,
       )
       from transformers.models.flaubert.modeling_flaubert import FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST







class 						__magic_name__			(							lowerCamelCase__							):

   '''simple docstring'''




   def __init__(				self,    lowercase_,    lowercase_=13,    lowercase_=7,    lowercase_=True,    lowercase_=True,    lowercase_=True,    lowercase_=True,    lowercase_=True,    lowercase_=False,    lowercase_=False,    lowercase_=False,    lowercase_=2,    lowercase_=99,    lowercase_=0,    lowercase_=32,    lowercase_=5,    lowercase_=4,    lowercase_=0.1,    lowercase_=0.1,    lowercase_=512,    lowercase_=12,    lowercase_=2,    lowercase_=0.02,    lowercase_=3,    lowercase_=4,    lowercase_="last",    lowercase_=None,    lowercase_=None,    )							->    List[Any]:






     """simple docstring"""






     a__  =parent
     a__  =batch_size
     a__  =seq_length
     a__  =is_training
     a__  =use_input_lengths
     a__  =use_token_type_ids
     a__  =use_labels
     a__  =gelu_activation
     a__  =sinusoidal_embeddings
     a__  =causal
     a__  =asm
     a__  =n_langs
     a__  =vocab_size
     a__  =n_special
     a__  =hidden_size
     a__  =num_hidden_layers
     a__  =num_attention_heads
     a__  =hidden_dropout_prob
     a__  =attention_probs_dropout_prob
     a__  =max_position_embeddings
     a__  =type_vocab_size
     a__  =type_sequence_label_size
     a__  =initializer_range
     a__  =num_labels
     a__  =num_choices
     a__  =summary_type
     a__  =use_proj
     a__  =scope



   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     a__  =ids_tensor([self.batch_size, self.seq_length],    self.vocab_size       )
     a__  =random_attention_mask([self.batch_size, self.seq_length]       )

     a__  =None
     if self.use_input_lengths:
       a__  =(
           ids_tensor([self.batch_size],    vocab_size=2       ) + self.seq_length - 2
       )  # small variation of seq_length

     a__  =None
     if self.use_token_type_ids:
       a__  =ids_tensor([self.batch_size, self.seq_length],    self.n_langs       )

     a__  =None
     a__  =None
     a__  =None
     if self.use_labels:
       a__  =ids_tensor([self.batch_size],    self.type_sequence_label_size       )
       a__  =ids_tensor([self.batch_size, self.seq_length],    self.num_labels       )
       a__  =ids_tensor([self.batch_size],    2       ).float()
       a__  =ids_tensor([self.batch_size],    self.num_choices       )

     a__  =self.get_config()

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



   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     return FlaubertConfig(
         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,    )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    )							->    Dict:






     """simple docstring"""






     a__  =FlaubertModel(config=lowercase_       )
     model.to(lowercase_       )
     model.eval()
     a__  =model(lowercase_,    lengths=lowercase_,    langs=lowercase_       )
     a__  =model(lowercase_,    langs=lowercase_       )
     a__  =model(lowercase_       )
     self.parent.assertEqual(result.last_hidden_state.shape,    (self.batch_size, self.seq_length, self.hidden_size)       )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    )							->    str:






     """simple docstring"""






     a__  =FlaubertWithLMHeadModel(lowercase_       )
     model.to(lowercase_       )
     model.eval()

     a__  =model(lowercase_,    token_type_ids=lowercase_,    labels=lowercase_       )
     self.parent.assertEqual(result.loss.shape,    ()       )
     self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length, self.vocab_size)       )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    )							->    Dict:






     """simple docstring"""






     a__  =FlaubertForQuestionAnsweringSimple(lowercase_       )
     model.to(lowercase_       )
     model.eval()

     a__  =model(lowercase_       )

     a__  =model(lowercase_,    start_positions=lowercase_,    end_positions=lowercase_       )
     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  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    )							->    Optional[Any]:






     """simple docstring"""






     a__  =FlaubertForQuestionAnswering(lowercase_       )
     model.to(lowercase_       )
     model.eval()

     a__  =model(lowercase_       )

     a__  =model(
         lowercase_,    start_positions=lowercase_,    end_positions=lowercase_,    cls_index=lowercase_,    is_impossible=lowercase_,    p_mask=lowercase_,    )

     a__  =model(
         lowercase_,    start_positions=lowercase_,    end_positions=lowercase_,    cls_index=lowercase_,    is_impossible=lowercase_,    )

     ((a__),      )  =result_with_labels.to_tuple()

     a__  =model(lowercase_,    start_positions=lowercase_,    end_positions=lowercase_       )

     ((a__),      )  =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  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    )							->    Optional[Any]:






     """simple docstring"""






     a__  =FlaubertForSequenceClassification(lowercase_       )
     model.to(lowercase_       )
     model.eval()

     a__  =model(lowercase_       )
     a__  =model(lowercase_,    labels=lowercase_       )

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



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    )							->    Optional[int]:






     """simple docstring"""






     a__  =self.num_labels
     a__  =FlaubertForTokenClassification(lowercase_       )
     model.to(lowercase_       )
     model.eval()

     a__  =model(lowercase_,    attention_mask=lowercase_,    labels=lowercase_       )
     self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.seq_length, self.num_labels)       )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    )							->    Dict:






     """simple docstring"""






     a__  =self.num_choices
     a__  =FlaubertForMultipleChoice(config=lowercase_       )
     model.to(lowercase_       )
     model.eval()
     a__  =input_ids.unsqueeze(1       ).expand(-1,    self.num_choices,    -1       ).contiguous()
     a__  =token_type_ids.unsqueeze(1       ).expand(-1,    self.num_choices,    -1       ).contiguous()
     a__  =input_mask.unsqueeze(1       ).expand(-1,    self.num_choices,    -1       ).contiguous()
     a__  =model(
         lowercase_,    attention_mask=lowercase_,    token_type_ids=lowercase_,    labels=lowercase_,    )
     self.parent.assertEqual(result.logits.shape,    (self.batch_size, self.num_choices)       )



   def  _UpperCAmelCase (				self       )							->    Dict:






     """simple docstring"""






     a__  =self.prepare_config_and_inputs()
     (
         (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      
     )  =config_and_inputs
     a__  ={
         '''input_ids''': input_ids,
         '''token_type_ids''': token_type_ids,
         '''lengths''': input_lengths,
         '''attention_mask''': input_mask,
     }
     return config, inputs_dict







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

   '''simple docstring'''




   lowerCamelCase__ :	str    =   (
       (
           FlaubertModel,
           FlaubertWithLMHeadModel,
           FlaubertForQuestionAnswering,
           FlaubertForQuestionAnsweringSimple,
           FlaubertForSequenceClassification,
           FlaubertForTokenClassification,
           FlaubertForMultipleChoice,
       )
       if is_torch_available()
       else ()
   )
   lowerCamelCase__ :	Dict    =   (
       {
           'feature-extraction': FlaubertModel,
           'fill-mask': FlaubertWithLMHeadModel,
           'question-answering': FlaubertForQuestionAnsweringSimple,
           'text-classification': FlaubertForSequenceClassification,
           'token-classification': FlaubertForTokenClassification,
           'zero-shot': FlaubertForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_       )							->    str:






     """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  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_=False       )							->    str:






     """simple docstring"""






     a__  =super()._prepare_for_class(lowercase_,    lowercase_,    return_labels=lowercase_       )

     if return_labels:
       if model_class.__name__ == "FlaubertForQuestionAnswering":
         a__  =torch.zeros(
             self.model_tester.batch_size,    dtype=torch.long,    device=lowercase_       )
         a__  =torch.zeros(
             self.model_tester.batch_size,    dtype=torch.long,    device=lowercase_       )

     return inputs_dict



   def  _UpperCAmelCase (				self       )							->    Optional[int]:






     """simple docstring"""






     a__  =FlaubertModelTester(self       )
     a__  =ConfigTester(self,    config_class=lowercase_,    emb_dim=37       )



   def  _UpperCAmelCase (				self       )							->    Optional[Any]:






     """simple docstring"""






     self.config_tester.run_common_tests()



   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_model(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    str:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_lm_head(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    Dict:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_simple_qa(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    Dict:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_qa(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_sequence_classif(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    Any:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_token_classif(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_flaubert_multiple_choice(*lowercase_       )



   @slow
   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






     for model_name in FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       a__  =FlaubertModel.from_pretrained(lowercase_       )
       self.assertIsNotNone(lowercase_       )



   @slow
   @require_torch_gpu
   def  _UpperCAmelCase (				self       )							->    int:






     """simple docstring"""






     a__,      a__  =self.model_tester.prepare_config_and_inputs_for_common()
     for model_class in self.all_model_classes:
       # FlauBertForMultipleChoice behaves incorrectly in JIT environments.
       if model_class == FlaubertForMultipleChoice:
         return

       a__  =True
       a__  =model_class(config=lowercase_       )

       a__  =self._prepare_for_class(lowercase_,    lowercase_       )
       a__  =torch.jit.trace(
           lowercase_,    (inputs_dict['''input_ids'''].to('''cpu'''       ), inputs_dict['''attention_mask'''].to('''cpu'''       ))       )

       with tempfile.TemporaryDirectory() as tmp:
         torch.jit.save(lowercase_,    os.path.join(lowercase_,    '''traced_model.pt'''       )       )
         a__  =torch.jit.load(os.path.join(lowercase_,    '''traced_model.pt'''       ),    map_location=lowercase_       )
         loaded(inputs_dict['''input_ids'''].to(lowercase_       ),    inputs_dict['''attention_mask'''].to(lowercase_       )       )







@require_torch
class 						__magic_name__			(							unittest.TestCase							):

   '''simple docstring'''




   @slow
   def  _UpperCAmelCase (				self       )							->    List[str]:






     """simple docstring"""






     a__  =FlaubertModel.from_pretrained('''flaubert/flaubert_base_cased'''       )
     a__  =torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]       )
     with torch.no_grad():
       a__  =model(lowercase_       )[0]
     a__  =torch.Size((1, 11, 768)       )
     self.assertEqual(output.shape,    lowercase_       )
     a__  =torch.tensor(
         [[[-2.6251, -1.4298, -0.0227], [-2.8510, -1.6387, 0.2258], [-2.8114, -1.1832, -0.3066]]]       )

     self.assertTrue(torch.allclose(output[:, :3, :3],    lowercase_,    atol=1E-4       )       )
