

'''simple docstring'''

import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    UniSpeechConfig,
    UniSpeechForCTC,
    UniSpeechForPreTraining,
    WavaVecaFeatureExtractor,
    WavaVecaPhonemeCTCTokenizer,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
a   :			Union[str, Any]         = logging.get_logger(__name__)

a   :			Union[str, Any]         = {
    "post_extract_proj": "feature_projection.projection",
    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
    "self_attn.k_proj": "encoder.layers.*.attention.k_proj",
    "self_attn.v_proj": "encoder.layers.*.attention.v_proj",
    "self_attn.q_proj": "encoder.layers.*.attention.q_proj",
    "self_attn.out_proj": "encoder.layers.*.attention.out_proj",
    "self_attn_layer_norm": "encoder.layers.*.layer_norm",
    "fc1": "encoder.layers.*.feed_forward.intermediate_dense",
    "fc2": "encoder.layers.*.feed_forward.output_dense",
    "final_layer_norm": "encoder.layers.*.final_layer_norm",
    "encoder.layer_norm": "encoder.layer_norm",
    "w2v_model.layer_norm": "feature_projection.layer_norm",
    "quantizer.weight_proj": "quantizer.weight_proj",
    "quantizer.vars": "quantizer.codevectors",
    "project_q": "project_q",
    "final_proj": "project_hid",
    "w2v_encoder.proj": "ctc_proj",
    "mask_emb": "masked_spec_embed",
}
a   :			List[Any]         = [
    "ctc_proj",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
]





def       lowercase					(     __magic_name__ ,    __magic_name__ ,    __magic_name__ ,    __magic_name__ ,    __magic_name__ ,    __magic_name__							):



					'''simple docstring'''







					for attribute in key.split("."							):
										if is_finetuned:
															if attribute in ["quantizer", "project_q", "project_hid"]:
																				# those layers are only relevant for pretraining and should be dropped
																				return

															if attribute == "ctc_proj":
																				# we should rename `ctc_proj` to `lm_head` for fine-tuned phoneme models
																				UpperCAmelCase		:							Tuple   					=   "lm_head"

										UpperCAmelCase		:							List[Any]   					=   getattr(_A ,    _A							)

					if weight_type is not None:
										UpperCAmelCase		:							List[Any]   					=   getattr(_A ,    _A							).shape
					else:
										UpperCAmelCase		:							Optional[int]   					=   hf_pointer.shape

					assert hf_shape == value.shape, (
					    F"Shape of hf {key + '.' + weight_type if weight_type is not None else ''} is {hf_shape}, but should be"
					    F" {value.shape} for {full_name}"
					)

					if weight_type == "weight":
										UpperCAmelCase		:							Any   					=   value
					elif weight_type == "weight_g":
										UpperCAmelCase		:							List[Any]   					=   value
					elif weight_type == "weight_v":
										UpperCAmelCase		:							Any   					=   value
					elif weight_type == "bias":
										UpperCAmelCase		:							int   					=   value
					else:
										UpperCAmelCase		:							List[Any]   					=   value

					logger.info(F"{key + '.' + weight_type if weight_type is not None else ''} was initialized from {full_name}."							)





def       lowercase					(     __magic_name__ ,    __magic_name__ ,    __magic_name__							):



					'''simple docstring'''







					UpperCAmelCase		:							int   					=   []
					UpperCAmelCase		:							Any   					=   fairseq_model.state_dict()

					UpperCAmelCase		:							List[Any]   					=   hf_model.unispeech.feature_extractor

					for name, value in fairseq_dict.items():
										UpperCAmelCase		:							int   					=   False
										if "conv_layers" in name:
															load_conv_layer(
															    _A ,    _A ,    _A ,    _A ,    hf_model.config.feat_extract_norm == "group" ,    )
															UpperCAmelCase		:							Optional[Any]   					=   True
										else:
															for key, mapped_key in MAPPING.items():
																				UpperCAmelCase		:							Union[str, Any]   					=   "unispeech." + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
																				if key in name or key.split("w2v_model."							)[-1] == name.split("."							)[0]:
																									UpperCAmelCase		:							Union[str, Any]   					=   True
																									if "*" in mapped_key:
																														UpperCAmelCase		:							Dict   					=   name.split(_A							)[0].split("."							)[-2]
																														UpperCAmelCase		:							Union[str, Any]   					=   mapped_key.replace("*" ,    _A							)
																									if "weight_g" in name:
																														UpperCAmelCase		:							Tuple   					=   "weight_g"
																									elif "weight_v" in name:
																														UpperCAmelCase		:							Optional[Any]   					=   "weight_v"
																									elif "bias" in name:
																														UpperCAmelCase		:							Dict   					=   "bias"
																									elif "weight" in name:
																														# TODO: don't match quantizer.weight_proj
																														UpperCAmelCase		:							int   					=   "weight"
																									else:
																														UpperCAmelCase		:							Optional[int]   					=   None
																									set_recursively(_A ,    _A ,    _A ,    _A ,    _A ,    _A							)
																				continue
										if not is_used:
															unused_weights.append(_A							)

					logger.warning(F"Unused weights: {unused_weights}"							)





def       lowercase					(     __magic_name__ ,    __magic_name__ ,    __magic_name__ ,    __magic_name__ ,    __magic_name__							):



					'''simple docstring'''







					UpperCAmelCase		:							int   					=   full_name.split("conv_layers."							)[-1]
					UpperCAmelCase		:							Union[str, Any]   					=   name.split("."							)
					UpperCAmelCase		:							Tuple   					=   int(items[0]							)
					UpperCAmelCase		:							Any   					=   int(items[1]							)

					if type_id == 0:
										if "bias" in name:
															assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
															    F"{full_name} has size {value.shape}, but"
															    F" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
															)
															UpperCAmelCase		:							Dict   					=   value
															logger.info(F"Feat extract conv layer {layer_id} was initialized from {full_name}."							)
										elif "weight" in name:
															assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
															    F"{full_name} has size {value.shape}, but"
															    F" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
															)
															UpperCAmelCase		:							Union[str, Any]   					=   value
															logger.info(F"Feat extract conv layer {layer_id} was initialized from {full_name}."							)
					elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
										if "bias" in name:
															assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
															    F"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
															    " found."
															)
															UpperCAmelCase		:							Dict   					=   value
															logger.info(F"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."							)
										elif "weight" in name:
															assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
															    F"{full_name} has size {value.shape}, but"
															    F" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
															)
															UpperCAmelCase		:							Optional[int]   					=   value
															logger.info(F"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."							)
					else:
										unused_weights.append(_A							)





@torch.no_grad()
def       lowercase					(     __magic_name__ ,    __magic_name__ ,    __magic_name__=None ,    __magic_name__=None ,    __magic_name__=True							):



					'''simple docstring'''







					if config_path is not None:
										UpperCAmelCase		:							List[str]   					=   UniSpeechConfig.from_pretrained(_A							)
					else:
										UpperCAmelCase		:							Optional[Any]   					=   UniSpeechConfig()

					if is_finetuned:
										if dict_path:
															UpperCAmelCase		:							List[Any]   					=   Dictionary.load_from_json(_A							)

															# important change bos & pad token id since CTC symbol is <pad> and
															# not <s> as in fairseq
															UpperCAmelCase		:							Any   					=   target_dict.pad_index
															UpperCAmelCase		:							Tuple   					=   target_dict.bos_index
															UpperCAmelCase		:							Tuple   					=   target_dict.eos_index
															UpperCAmelCase		:							Any   					=   len(target_dict.symbols							)
															UpperCAmelCase		:							Dict   					=   os.path.join(_A ,    "vocab.json"							)
															if not os.path.isdir(_A							):
																				logger.error("--pytorch_dump_folder_path ({}) should be a directory".format(_A							)							)
																				return
															os.makedirs(_A ,    exist_ok=_A							)
															UpperCAmelCase		:							Optional[int]   					=   target_dict.indices

															# fairseq has the <pad> and <s> switched
															UpperCAmelCase		:							Any   					=   42
															UpperCAmelCase		:							str   					=   43
															with open(_A ,    "w" ,    encoding="utf-8"							) as vocab_handle:
																				json.dump(_A ,    _A							)
															UpperCAmelCase		:							str   					=   WavaVecaPhonemeCTCTokenizer(
															    _A ,    unk_token=target_dict.unk_word ,    pad_token=target_dict.pad_word ,    bos_token=target_dict.bos_word ,    eos_token=target_dict.eos_word ,    word_delimiter_token="|" ,    do_lower_case=_A ,    )
															UpperCAmelCase		:							Tuple   					=   True if config.feat_extract_norm == "layer" else False
															UpperCAmelCase		:							str   					=   WavaVecaFeatureExtractor(
															    feature_size=1 ,    sampling_rate=1_6000 ,    padding_value=0 ,    do_normalize=_A ,    return_attention_mask=_A ,    )
															UpperCAmelCase		:							Union[str, Any]   					=   WavaVecaProcessor(feature_extractor=_A ,    tokenizer=_A							)
															processor.save_pretrained(_A							)

										UpperCAmelCase		:							int   					=   UniSpeechForCTC(_A							)
					else:
										UpperCAmelCase		:							List[Any]   					=   UniSpeechForPreTraining(_A							)

					if is_finetuned:
										UpperCAmelCase					, UpperCAmelCase					, UpperCAmelCase		:							List[str]   					=   fairseq.checkpoint_utils.load_model_ensemble_and_task(
										    [checkpoint_path] ,    arg_overrides={"data": "/".join(dict_path.split("/"							)[:-1]							), "w2v_path": checkpoint_path}							)
					else:
										UpperCAmelCase					, UpperCAmelCase					, UpperCAmelCase		:							Any   					=   fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]							)

					UpperCAmelCase		:							List[str]   					=   model[0].eval()

					recursively_load_weights(_A ,    _A ,    _A							)

					hf_unispeech.save_pretrained(_A							)


if __name__ == "__main__":
				a   :			str         = argparse.ArgumentParser()
				parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
				parser.add_argument("--checkpoint_path", default=None, type=str, help="Path to fairseq checkpoint")
				parser.add_argument("--dict_path", default=None, type=str, help="Path to dict of fine-tuned model")
				parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
				parser.add_argument(
				    "--not_finetuned", action="store_true", help="Whether the model to convert is a fine-tuned model or not"
				)
				a   :			str         = parser.parse_args()
				convert_unispeech_checkpoint(
				    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
				)



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       )       )
