'''simple docstring'''

from __future__ import annotations

import unittest

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

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


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TFRoFormerForCausalLM,
      TFRoFormerForMaskedLM,
      TFRoFormerForMultipleChoice,
      TFRoFormerForQuestionAnswering,
      TFRoFormerForSequenceClassification,
      TFRoFormerForTokenClassification,
      TFRoFormerModel,
  )
  from transformers.models.roformer.modeling_tf_roformer import (
      TFRoFormerSelfAttention,
      TFRoFormerSinusoidalPositionalEmbedding,
  )



class 			UpperCAmelCase  :





       '''simple docstring'''



       def __init__(						self	,   __lowerCAmelCase	,   __lowerCAmelCase=13	,   __lowerCAmelCase=7	,   __lowerCAmelCase=True	,   __lowerCAmelCase=True	,   __lowerCAmelCase=True	,   __lowerCAmelCase=True	,   __lowerCAmelCase=99	,   __lowerCAmelCase=32	,   __lowerCAmelCase=2	,   __lowerCAmelCase=4	,   __lowerCAmelCase=37	,   __lowerCAmelCase="gelu"	,   __lowerCAmelCase=0.1	,   __lowerCAmelCase=0.1	,   __lowerCAmelCase=512	,   __lowerCAmelCase=16	,   __lowerCAmelCase=2	,   __lowerCAmelCase=0.0_2	,   __lowerCAmelCase=3	,   __lowerCAmelCase=4	,   __lowerCAmelCase=None	,   )  ->  Any:
        lowercase__				:    Union[str, Any]  =					parent
        lowercase__				:    List[str]  =					13
        lowercase__				:    Union[str, Any]  =					7
        lowercase__				:    int  =					True
        lowercase__				:    Optional[int]  =					True
        lowercase__				:    Tuple  =					True
        lowercase__				:    List[Any]  =					True
        lowercase__				:    Union[str, Any]  =					99
        lowercase__				:    List[str]  =					32
        lowercase__				:    Optional[Any]  =					2
        lowercase__				:    Union[str, Any]  =					4
        lowercase__				:    str  =					37
        lowercase__				:    Union[str, Any]  =					"""gelu"""
        lowercase__				:    str  =					0.1
        lowercase__				:    List[str]  =					0.1
        lowercase__				:    str  =					512
        lowercase__				:    int  =					16
        lowercase__				:    List[str]  =					2
        lowercase__				:    Optional[Any]  =					0.0_2
        lowercase__				:    Optional[Any]  =					3
        lowercase__				:    List[Any]  =					4
        lowercase__				:    Dict  =					None

       def _lowerCAmelCase(						self )  ->  List[str]:
        lowercase__				:    List[str]  =					ids_tensor([self.batch_size, self.seq_length]	,   self.vocab_size )

        lowercase__				:    Optional[int]  =					None
        if self.use_input_mask:
         lowercase__				:    Optional[int]  =					random_attention_mask([self.batch_size, self.seq_length] )

        lowercase__				:    Optional[Any]  =					None
        if self.use_token_type_ids:
         lowercase__				:    Dict  =					ids_tensor([self.batch_size, self.seq_length]	,   self.type_vocab_size )

        lowercase__				:    Optional[Any]  =					None
        lowercase__				:    Any  =					None
        lowercase__				:    int  =					None
        if self.use_labels:
         lowercase__				:    Any  =					ids_tensor([self.batch_size]	,   self.type_sequence_label_size )
         lowercase__				:    Union[str, Any]  =					ids_tensor([self.batch_size, self.seq_length]	,   self.num_labels )
         lowercase__				:    Tuple  =					ids_tensor([self.batch_size]	,   self.num_choices )

        lowercase__				:    Dict  =					RoFormerConfig(
            vocab_size=self.vocab_size	,   hidden_size=self.hidden_size	,   num_hidden_layers=self.num_hidden_layers	,   num_attention_heads=self.num_attention_heads	,   intermediate_size=self.intermediate_size	,   hidden_act=self.hidden_act	,   hidden_dropout_prob=self.hidden_dropout_prob	,   attention_probs_dropout_prob=self.attention_probs_dropout_prob	,   max_position_embeddings=self.max_position_embeddings	,   type_vocab_size=self.type_vocab_size	,   initializer_range=self.initializer_range	,   return_dict=__lowerCAmelCase	,   )

        return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  List[Any]:
        lowercase__				:    Union[str, Any]  =					TFRoFormerModel(config=__lowerCAmelCase )
        lowercase__				:    Optional[int]  =					{"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

        lowercase__				:    int  =					[input_ids, input_mask]
        lowercase__				:    Any  =					model(__lowerCAmelCase )

        lowercase__				:    Tuple  =					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 )  ->  str:
        lowercase__				:    str  =					True
        lowercase__				:    Tuple  =					TFRoFormerForCausalLM(config=__lowerCAmelCase )
        lowercase__				:    str  =					{
            """input_ids""": input_ids,
            """attention_mask""": input_mask,
            """token_type_ids""": token_type_ids,
        }
        lowercase__				:    Tuple  =					model(__lowerCAmelCase )["""logits"""]
        self.parent.assertListEqual(
            list(prediction_scores.numpy().shape )	,   [self.batch_size, self.seq_length, self.vocab_size] )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  Union[str, Any]:
        lowercase__				:    Optional[int]  =					TFRoFormerForMaskedLM(config=__lowerCAmelCase )
        lowercase__				:    Dict  =					{
            """input_ids""": input_ids,
            """attention_mask""": input_mask,
            """token_type_ids""": token_type_ids,
        }
        lowercase__				:    Dict  =					model(__lowerCAmelCase )
        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 )  ->  Dict:
        lowercase__				:    Dict  =					self.num_labels
        lowercase__				:    Optional[int]  =					TFRoFormerForSequenceClassification(config=__lowerCAmelCase )
        lowercase__				:    str  =					{
            """input_ids""": input_ids,
            """attention_mask""": input_mask,
            """token_type_ids""": token_type_ids,
        }

        lowercase__				:    Dict  =					model(__lowerCAmelCase )
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_labels) )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  Dict:
        lowercase__				:    Any  =					self.num_choices
        lowercase__				:    str  =					TFRoFormerForMultipleChoice(config=__lowerCAmelCase )
        lowercase__				:    List[str]  =					tf.tile(tf.expand_dims(__lowerCAmelCase	,   1 )	,   (1, self.num_choices, 1) )
        lowercase__				:    Dict  =					tf.tile(tf.expand_dims(__lowerCAmelCase	,   1 )	,   (1, self.num_choices, 1) )
        lowercase__				:    int  =					tf.tile(tf.expand_dims(__lowerCAmelCase	,   1 )	,   (1, self.num_choices, 1) )
        lowercase__				:    Tuple  =					{
            """input_ids""": multiple_choice_inputs_ids,
            """attention_mask""": multiple_choice_input_mask,
            """token_type_ids""": multiple_choice_token_type_ids,
        }
        lowercase__				:    Optional[Any]  =					model(__lowerCAmelCase )
        self.parent.assertEqual(result.logits.shape	,   (self.batch_size, self.num_choices) )

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  str:
        lowercase__				:    List[Any]  =					self.num_labels
        lowercase__				:    List[str]  =					TFRoFormerForTokenClassification(config=__lowerCAmelCase )
        lowercase__				:    Optional[Any]  =					{
            """input_ids""": input_ids,
            """attention_mask""": input_mask,
            """token_type_ids""": token_type_ids,
        }
        lowercase__				:    int  =					model(__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 )  ->  List[Any]:
        lowercase__				:    str  =					TFRoFormerForQuestionAnswering(config=__lowerCAmelCase )
        lowercase__				:    Optional[int]  =					{
            """input_ids""": input_ids,
            """attention_mask""": input_mask,
            """token_type_ids""": token_type_ids,
        }

        lowercase__				:    Any  =					model(__lowerCAmelCase )
        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 )  ->  int:
        lowercase__				:    Any  =					self.prepare_config_and_inputs()
        (
            lowercase__    
        )				:    Optional[int]  =					config_and_inputs
        lowercase__				:    str  =					{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
        return config, inputs_dict



@require_tf
class 			UpperCAmelCase  (						__SCREAMING_SNAKE_CASE    ,						__SCREAMING_SNAKE_CASE    ,						unittest.TestCase					):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE							=    (
           (
               TFRoFormerModel,
               TFRoFormerForCausalLM,
               TFRoFormerForMaskedLM,
               TFRoFormerForQuestionAnswering,
               TFRoFormerForSequenceClassification,
               TFRoFormerForTokenClassification,
               TFRoFormerForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       SCREAMING_SNAKE_CASE							=    (
           {
               """feature-extraction""": TFRoFormerModel,
               """fill-mask""": TFRoFormerForMaskedLM,
               """question-answering""": TFRoFormerForQuestionAnswering,
               """text-classification""": TFRoFormerForSequenceClassification,
               """text-generation""": TFRoFormerForCausalLM,
               """token-classification""": TFRoFormerForTokenClassification,
               """zero-shot""": TFRoFormerForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )

       SCREAMING_SNAKE_CASE							=    False
       SCREAMING_SNAKE_CASE							=    False

       def _lowerCAmelCase(						self	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )  ->  Dict:
        if pipeline_test_casse_name == "TextGenerationPipelineTests":
         return True

        return False

       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        lowercase__				:    str  =					TFRoFormerModelTester(self )
        lowercase__				:    Optional[int]  =					ConfigTester(self	,   config_class=__lowerCAmelCase	,   hidden_size=37 )

       def _lowerCAmelCase(						self )  ->  Tuple:
        self.config_tester.run_common_tests()

       def _lowerCAmelCase(						self )  ->  List[Any]:
        lowercase__				:    List[str]  =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Dict:
        lowercase__				:    Tuple  =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_lm(*__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Dict:
        lowercase__				:    Any  =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_lm_head(*__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Any:
        lowercase__				:    Any  =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_multiple_choice(*__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        lowercase__				:    Dict  =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  List[str]:
        lowercase__				:    Tuple  =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*__lowerCAmelCase )

       def _lowerCAmelCase(						self )  ->  Tuple:
        lowercase__				:    List[str]  =					self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*__lowerCAmelCase )


       @slow
       def _lowerCAmelCase(						self )  ->  Union[str, Any]:
        lowercase__				:    Tuple  =					TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base''' )
        self.assertIsNotNone(__lowerCAmelCase )



@require_tf
class 			UpperCAmelCase  (						unittest.TestCase					):





       '''simple docstring'''



       @slow
       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        lowercase__				:    Any  =					TFRoFormerForMaskedLM.from_pretrained('''junnyu/roformer_chinese_base''' )
        lowercase__				:    Optional[int]  =					tf.constant([[0, 1, 2, 3, 4, 5]] )
        lowercase__				:    Optional[Any]  =					model(__lowerCAmelCase )[0]

        # TODO Replace vocab size
        lowercase__				:    Optional[Any]  =					50000

        lowercase__				:    Union[str, Any]  =					[1, 6, vocab_size]
        self.assertEqual(output.shape	,   __lowerCAmelCase )

        print(output[:, :3, :3] )

        # TODO Replace values below with what was printed above.
        lowercase__				:    Union[str, Any]  =					tf.constant(
            [
                [
                    [-0.1_2_0_5_3_3_4_1, -1.0_2_6_4_9_0_1, 0.2_9_2_2_1_9_4_6],
                    [-1.5_1_3_3_7_8_3, 0.1_9_7_4_3_3, 0.1_5_1_9_0_6_0_7],
                    [-5.0_1_3_5_4_0_3, -3.9_0_0_2_5_6, -0.8_4_0_3_8_7_6_4],
                ]
            ] )
        tf.debugging.assert_near(output[:, :3, :3]	,   __lowerCAmelCase	,   atol=1E-4 )



@require_tf
class 			UpperCAmelCase  (						unittest.TestCase					):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE							=    1e-4

       def _lowerCAmelCase(						self )  ->  List[str]:
        lowercase__				:    List[str]  =					tf.constant([[4, 10]] )
        lowercase__				:    Optional[int]  =					TFRoFormerSinusoidalPositionalEmbedding(num_positions=6	,   embedding_dim=6 )

        lowercase__				:    Optional[Any]  =					emba(input_ids.shape )
        lowercase__				:    Tuple  =					tf.constant(
            [[0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0], [0.8_4_1_5, 0.0_4_6_4, 0.0_0_2_2, 0.5_4_0_3, 0.9_9_8_9, 1.0_0_0_0]] )

        tf.debugging.assert_near(__lowerCAmelCase	,   __lowerCAmelCase	,   atol=self.tolerance )


       def _lowerCAmelCase(						self )  ->  Union[str, Any]:
        lowercase__				:    Union[str, Any]  =					tf.constant(
            [
                [0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0],
                [0.8_4_1_5, 0.8_2_1_9, 0.8_0_2_0, 0.7_8_1_9, 0.7_6_1_7],
                [0.9_0_9_3, 0.9_3_6_4, 0.9_5_8_1, 0.9_7_4_9, 0.9_8_7_0],
            ] )
        lowercase__				:    Dict  =					TFRoFormerSinusoidalPositionalEmbedding(num_positions=512	,   embedding_dim=512 )
        emba([2, 16, 512] )
        lowercase__				:    List[str]  =					emba.weight[:3, :5]

        tf.debugging.assert_near(__lowerCAmelCase	,   __lowerCAmelCase	,   atol=self.tolerance )



@require_tf
class 			UpperCAmelCase  (						unittest.TestCase					):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE							=    1e-4

       def _lowerCAmelCase(						self )  ->  Optional[Any]:
        # 2,12,16,64
        lowercase__				:    Union[str, Any]  =					tf.reshape(tf.range(2 * 12 * 16 * 64	,   dtype=tf.floataa )	,   shape=(2, 12, 16, 64) ) / 100

        lowercase__				:    Dict  =					-tf.reshape(tf.range(2 * 12 * 16 * 64	,   dtype=tf.floataa )	,   shape=(2, 12, 16, 64) ) / 100

        lowercase__				:    Union[str, Any]  =					TFRoFormerSinusoidalPositionalEmbedding(num_positions=32	,   embedding_dim=64 )
        lowercase__				:    List[str]  =					embed_positions([2, 16, 768] )[None, None, :, :]

        lowercase__				:    Any  =					TFRoFormerSelfAttention.apply_rotary_position_embeddings(
            __lowerCAmelCase	,   __lowerCAmelCase	,   __lowerCAmelCase )

        lowercase__				:    Union[str, Any]  =					tf.constant(
            [
                [0.0_0_0_0, 0.0_1_0_0, 0.0_2_0_0, 0.0_3_0_0, 0.0_4_0_0, 0.0_5_0_0, 0.0_6_0_0, 0.0_7_0_0],
                [-0.2_0_1_2, 0.8_8_9_7, 0.0_2_6_3, 0.9_4_0_1, 0.2_0_7_4, 0.9_4_6_3, 0.3_4_8_1, 0.9_3_4_3],
                [-1.7_0_5_7, 0.6_2_7_1, -1.2_1_4_5, 1.3_8_9_7, -0.6_3_0_3, 1.7_6_4_7, -0.1_1_7_3, 1.8_9_8_5],
                [-2.1_7_3_1, -1.6_3_9_7, -2.7_3_5_8, 0.2_8_5_4, -2.1_8_4_0, 1.7_1_8_3, -1.3_0_1_8, 2.4_8_7_1],
                [0.2_7_1_7, -3.6_1_7_3, -2.9_2_0_6, -2.1_9_8_8, -3.6_6_3_8, 0.3_8_5_8, -2.9_1_5_5, 2.2_9_8_0],
                [3.9_8_5_9, -2.1_5_8_0, -0.7_9_8_4, -4.4_9_0_4, -4.1_1_8_1, -2.0_2_5_2, -4.4_7_8_2, 1.1_2_5_3],
            ] )
        lowercase__				:    str  =					tf.constant(
            [
                [0.0_0_0_0, -0.0_1_0_0, -0.0_2_0_0, -0.0_3_0_0, -0.0_4_0_0, -0.0_5_0_0, -0.0_6_0_0, -0.0_7_0_0],
                [0.2_0_1_2, -0.8_8_9_7, -0.0_2_6_3, -0.9_4_0_1, -0.2_0_7_4, -0.9_4_6_3, -0.3_4_8_1, -0.9_3_4_3],
                [1.7_0_5_7, -0.6_2_7_1, 1.2_1_4_5, -1.3_8_9_7, 0.6_3_0_3, -1.7_6_4_7, 0.1_1_7_3, -1.8_9_8_5],
                [2.1_7_3_1, 1.6_3_9_7, 2.7_3_5_8, -0.2_8_5_4, 2.1_8_4_0, -1.7_1_8_3, 1.3_0_1_8, -2.4_8_7_1],
                [-0.2_7_1_7, 3.6_1_7_3, 2.9_2_0_6, 2.1_9_8_8, 3.6_6_3_8, -0.3_8_5_8, 2.9_1_5_5, -2.2_9_8_0],
                [-3.9_8_5_9, 2.1_5_8_0, 0.7_9_8_4, 4.4_9_0_4, 4.1_1_8_1, 2.0_2_5_2, 4.4_7_8_2, -1.1_2_5_3],
            ] )

        tf.debugging.assert_near(query_layer[0, 0, :6, :8]	,   __lowerCAmelCase	,   atol=self.tolerance )
        tf.debugging.assert_near(key_layer[0, 0, :6, :8]	,   __lowerCAmelCase	,   atol=self.tolerance )



from . import __version__

# Backward compatibility imports, to make sure all those objects can be found in file_utils
from .utils import (
    CLOUDFRONT_DISTRIB_PREFIX,
    CONFIG_NAME,
    DISABLE_TELEMETRY,
    DUMMY_INPUTS,
    DUMMY_MASK,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    FEATURE_EXTRACTOR_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    MODEL_CARD_NAME,
    MULTIPLE_CHOICE_DUMMY_INPUTS,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    SENTENCEPIECE_UNDERLINE,
    SPIECE_UNDERLINE,
    TF2_WEIGHTS_NAME,
    TF_WEIGHTS_NAME,
    TORCH_FX_REQUIRED_VERSION,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
    ContextManagers,
    DummyObject,
    EntryNotFoundError,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    TensorType,
    _LazyModule,
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    cached_property,
    copy_func,
    default_cache_path,
    define_sagemaker_information,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    get_torch_version,
    has_file,
    http_user_agent,
    is_apex_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_datasets_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_librosa_available,
    is_offline_mode,
    is_onnx_available,
    is_pandas_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_tensor,
    is_tensorflow_probability_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    replace_return_docstrings,
    requires_backends,
    to_numpy,
    to_py_obj,
    torch_only_method,
)




