"""
    #################################################################################################################################################################################################
    # This code library is an adaptation of the original Transformers and was designed, developed and programmed by Sapiens Technology®.                                                            #
    # Any alteration and/or disclosure of this code without prior authorization is strictly prohibited and is subject to legal action that will be forwarded by the Sapiens Technology® legal team. #
    # This set of algorithms aims to download, train, fine-tune and/or infer large language models from various sources and slopes.                                                                 #
    #################################################################################################################################################################################################
"""
from ..utils import DummyObject, requires_backends
class PyTorchBenchmark(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PyTorchBenchmarkArguments(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Cache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CacheConfig(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DynamicCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EncoderDecoderCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HQQQuantizedCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HybridCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MambaCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OffloadedCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OffloadedStaticCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QuantizedCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QuantizedCacheConfig(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QuantoQuantizedCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SinkCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SlidingWindowCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class StaticCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GlueDataset(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GlueDataTrainingArguments(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LineByLineTextDataset(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LineByLineWithRefDataset(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LineByLineWithSOPTextDataset(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SquadDataset(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SquadDataTrainingArguments(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TextDataset(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TextDatasetForNextSentencePrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlternatingCodebooksLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BeamScorer(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BeamSearchScorer(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClassifierFreeGuidanceLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConstrainedBeamSearchScorer(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Constraint(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConstraintListState(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DisjunctiveConstraint(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EncoderNoRepeatNGramLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EncoderRepetitionPenaltyLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EosTokenCriteria(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EpsilonLogitsWarper(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EtaLogitsWarper(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ExponentialDecayLengthPenalty(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ForcedBOSTokenLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ForcedEOSTokenLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GenerationMixin(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HammingDiversityLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InfNanRemoveLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LogitNormalization(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LogitsProcessorList(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LogitsWarper(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MaxLengthCriteria(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MaxTimeCriteria(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MinLengthLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MinNewTokensLengthLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MinPLogitsWarper(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NoBadWordsLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NoRepeatNGramLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PhrasalConstraint(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PrefixConstrainedLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RepetitionPenaltyLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIAudioTimeStampLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SequenceBiasLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class StoppingCriteria(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class StoppingCriteriaList(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class StopStringCriteria(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SuppressTokensAtBeginLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SuppressTokensLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TemperatureLogitsWarper(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TopKLogitsWarper(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TopPLogitsWarper(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TypicalLogitsWarper(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UnbatchedClassifierFreeGuidanceLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WatermarkDetector(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WatermarkLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WhisperTimeStampLogitsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TorchExportableModuleWithStaticCache(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def convert_and_export_with_cache(*args, **kwargs): requires_backends(convert_and_export_with_cache, ["torch"])
ROPE_INIT_FUNCTIONS = None
class PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlbertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlbertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlbertForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlbertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlbertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlbertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlbertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlbertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_albert(*args, **kwargs): requires_backends(load_tf_weights_in_albert, ["torch"])
class AlignModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlignPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlignTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AlignVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AltCLIPModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AltCLIPPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AltCLIPTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AltCLIPVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ASTForAudioClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ASTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ASTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING = None
MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING = None
MODEL_FOR_AUDIO_XVECTOR_MAPPING = None
MODEL_FOR_BACKBONE_MAPPING = None
MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING = None
MODEL_FOR_CAUSAL_LM_MAPPING = None
MODEL_FOR_CTC_MAPPING = None
MODEL_FOR_DEPTH_ESTIMATION_MAPPING = None
MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING = None
MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING = None
MODEL_FOR_IMAGE_MAPPING = None
MODEL_FOR_IMAGE_SEGMENTATION_MAPPING = None
MODEL_FOR_IMAGE_TO_IMAGE_MAPPING = None
MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING = None
MODEL_FOR_KEYPOINT_DETECTION_MAPPING = None
MODEL_FOR_MASK_GENERATION_MAPPING = None
MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING = None
MODEL_FOR_MASKED_LM_MAPPING = None
MODEL_FOR_MULTIPLE_CHOICE_MAPPING = None
MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING = None
MODEL_FOR_OBJECT_DETECTION_MAPPING = None
MODEL_FOR_PRETRAINING_MAPPING = None
MODEL_FOR_QUESTION_ANSWERING_MAPPING = None
MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING = None
MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING = None
MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING = None
MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING = None
MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING = None
MODEL_FOR_TEXT_ENCODING_MAPPING = None
MODEL_FOR_TEXT_TO_SPECTROGRAM_MAPPING = None
MODEL_FOR_TEXT_TO_WAVEFORM_MAPPING = None
MODEL_FOR_TIME_SERIES_CLASSIFICATION_MAPPING = None
MODEL_FOR_TIME_SERIES_REGRESSION_MAPPING = None
MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING = None
MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING = None
MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING = None
MODEL_FOR_VISION_2_SEQ_MAPPING = None
MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING = None
MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING = None
MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING = None
MODEL_MAPPING = None
MODEL_WITH_LM_HEAD_MAPPING = None
class AutoBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForAudioClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForAudioFrameClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForAudioXVector(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForDepthEstimation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForDocumentQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForImageSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForImageToImage(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForInstanceSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForKeypointDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForMaskedImageModeling(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForMaskGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForNextSentencePrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForSemanticSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForSeq2SeqLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForSpeechSeq2Seq(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForTableQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForTextEncoding(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForTextToSpectrogram(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForTextToWaveform(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForUniversalSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForVideoClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForVision2Seq(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForVisualQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForZeroShotImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelForZeroShotObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoModelWithLMHead(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoformerForPrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AutoformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BarkCausalModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BarkCoarseModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BarkFineModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BarkModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BarkPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BarkSemanticModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BartForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BartForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BartForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BartForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BartModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BartPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BartPretrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PretrainedBartModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BeitBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BeitForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BeitForMaskedImageModeling(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BeitForSemanticSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BeitModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BeitPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertForNextSentencePrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertLMHeadModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_bert(*args, **kwargs): requires_backends(load_tf_weights_in_bert, ["torch"])
class BertGenerationDecoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertGenerationEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BertGenerationPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_bert_generation(*args, **kwargs): requires_backends(load_tf_weights_in_bert_generation, ["torch"])
class BigBirdForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_big_bird(*args, **kwargs): requires_backends(load_tf_weights_in_big_bird, ["torch"])
class BigBirdPegasusForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdPegasusForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdPegasusForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdPegasusForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdPegasusModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BigBirdPegasusPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BioGptForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BioGptForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BioGptForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BioGptModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BioGptPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BitBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BitForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BitModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BitPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlenderbotForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlenderbotForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlenderbotModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlenderbotPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlenderbotSmallForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlenderbotSmallForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlenderbotSmallModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlenderbotSmallPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlipForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlipForImageTextRetrieval(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlipForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlipModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlipPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlipTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BlipVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Blip2ForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Blip2ForImageTextRetrieval(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Blip2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Blip2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Blip2QFormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Blip2TextModelWithProjection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Blip2VisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Blip2VisionModelWithProjection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BloomForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BloomForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BloomForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BloomForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BloomModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BloomPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BridgeTowerForContrastiveLearning(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BridgeTowerForImageAndTextRetrieval(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BridgeTowerForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BridgeTowerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BridgeTowerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BrosForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BrosModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BrosPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BrosProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BrosSpadeEEForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class BrosSpadeELForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CamembertForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CamembertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CamembertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CamembertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CamembertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CamembertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CamembertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CamembertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CanineForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CanineForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CanineForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CanineForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CanineModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CaninePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_canine(*args, **kwargs): requires_backends(load_tf_weights_in_canine, ["torch"])
class ChameleonForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ChameleonModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ChameleonPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ChameleonProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ChameleonVQVAE(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ChineseCLIPModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ChineseCLIPPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ChineseCLIPTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ChineseCLIPVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClapAudioModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClapAudioModelWithProjection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClapFeatureExtractor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClapModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClapPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClapTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClapTextModelWithProjection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPTextModelWithProjection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPVisionModelWithProjection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPSegForImageSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPSegModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPSegPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPSegTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CLIPSegVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClvpDecoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClvpEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClvpForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClvpModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClvpModelForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ClvpPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CodeGenForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CodeGenModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CodeGenPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CohereForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CohereModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CoherePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConditionalDetrForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConditionalDetrForSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConditionalDetrModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConditionalDetrPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvBertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvBertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvBertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvBertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvBertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_convbert(*args, **kwargs): requires_backends(load_tf_weights_in_convbert, ["torch"])
class ConvNextBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvNextForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvNextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvNextPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvNextV2Backbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvNextV2ForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvNextV2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ConvNextV2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CpmAntForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CpmAntModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CpmAntPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CTRLForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CTRLLMHeadModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CTRLModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CTRLPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CvtForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CvtModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class CvtPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DacModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DacPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecAudioForAudioFrameClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecAudioForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecAudioForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecAudioForXVector(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecAudioModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecAudioPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecTextForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecTextForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecTextForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecTextForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecTextForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecTextForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecTextPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecVisionForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecVisionForSemanticSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Data2VecVisionPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DbrxForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DbrxModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DbrxPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaV2ForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaV2ForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaV2ForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaV2ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaV2ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaV2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DebertaV2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DecisionTransformerGPT2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DecisionTransformerGPT2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DecisionTransformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DecisionTransformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DeformableDetrForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DeformableDetrModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DeformableDetrPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DeiTForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DeiTForImageClassificationWithTeacher(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DeiTForMaskedImageModeling(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DeiTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DeiTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DetaForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DetaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DetaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EfficientFormerForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EfficientFormerForImageClassificationWithTeacher(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EfficientFormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EfficientFormerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieMForInformationExtraction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieMForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieMForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieMForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieMForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieMModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieMPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTSanJapaneseForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTSanJapaneseModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTSanJapanesePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GraphormerForGraphClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GraphormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GraphormerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JukeboxModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JukeboxPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JukeboxPrior(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JukeboxVQVAE(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MCTCTForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MCTCTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MCTCTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegaForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegaForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegaForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegaForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegaForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MMBTForClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MMBTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ModalEmbeddings(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NatBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NatForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NatModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NatPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NezhaForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NezhaForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NezhaForNextSentencePrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NezhaForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NezhaForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NezhaForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NezhaForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NezhaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NezhaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OpenLlamaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OpenLlamaForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OpenLlamaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OpenLlamaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QDQBertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QDQBertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QDQBertForNextSentencePrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QDQBertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QDQBertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QDQBertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QDQBertLMHeadModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QDQBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class QDQBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_qdqbert(*args, **kwargs): requires_backends(load_tf_weights_in_qdqbert, ["torch"])
class RealmEmbedder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RealmForOpenQA(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RealmKnowledgeAugEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RealmPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RealmReader(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RealmRetriever(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RealmScorer(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_realm(*args, **kwargs): requires_backends(load_tf_weights_in_realm, ["torch"])
class RetriBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RetriBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Speech2Text2ForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Speech2Text2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TrajectoryTransformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TrajectoryTransformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AdaptiveEmbedding(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TransfoXLForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TransfoXLLMHeadModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TransfoXLModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TransfoXLPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_transfo_xl(*args, **kwargs): requires_backends(load_tf_weights_in_transfo_xl, ["torch"])
class TvltForAudioVisualClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TvltForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TvltModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TvltPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VanForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VanModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VanPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTHybridForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTHybridModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTHybridPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMProphetNetDecoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMProphetNetEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMProphetNetForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMProphetNetForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMProphetNetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMProphetNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DepthAnythingForDepthEstimation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DepthAnythingPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DetrForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DetrForSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DetrModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DetrPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DinatBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DinatForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DinatModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DinatPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Dinov2Backbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Dinov2ForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Dinov2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Dinov2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DistilBertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DistilBertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DistilBertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DistilBertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DistilBertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DistilBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DistilBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DonutSwinModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DonutSwinPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPRContextEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPRPretrainedContextEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPRPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPRPretrainedQuestionEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPRPretrainedReader(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPRQuestionEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPRReader(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPTForDepthEstimation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPTForSemanticSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class DPTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EfficientNetForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EfficientNetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EfficientNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ElectraForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ElectraForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ElectraForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ElectraForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ElectraForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ElectraForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ElectraForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ElectraModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ElectraPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_electra(*args, **kwargs): requires_backends(load_tf_weights_in_electra, ["torch"])
class EncodecModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EncodecPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EncoderDecoderModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EntityForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EntityForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EntityForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EntityForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EntityModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EntityPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieForNextSentencePrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErnieModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ErniePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EsmFoldPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EsmForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EsmForProteinFolding(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EsmForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EsmForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EsmModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class EsmPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FalconForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FalconForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FalconForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FalconForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FalconModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FalconPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FalconMambaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FalconMambaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FalconMambaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FastSpeech2ConformerHifiGan(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FastSpeech2ConformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FastSpeech2ConformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FastSpeech2ConformerWithHifiGan(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlaubertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlaubertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlaubertForQuestionAnsweringSimple(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlaubertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlaubertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlaubertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlaubertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlaubertWithLMHeadModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlavaForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlavaImageCodebook(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlavaImageModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlavaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlavaMultimodalModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlavaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FlavaTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FNetForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FNetForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FNetForNextSentencePrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FNetForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FNetForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FNetForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FNetForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FNetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FocalNetBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FocalNetForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FocalNetForMaskedImageModeling(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FocalNetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FocalNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FSMTForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FSMTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PretrainedFSMTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FunnelBaseModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FunnelForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FunnelForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FunnelForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FunnelForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FunnelForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FunnelForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FunnelModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FunnelPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_funnel(*args, **kwargs): requires_backends(load_tf_weights_in_funnel, ["torch"])
class FuyuForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class FuyuPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GemmaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GemmaForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GemmaForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GemmaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GemmaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Gemma2ForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Gemma2ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Gemma2ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Gemma2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Gemma2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GitForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GitModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GitPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GitVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GLPNForDepthEstimation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GLPNModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GLPNPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPT2DoubleHeadsModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPT2ForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPT2ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPT2ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPT2LMHeadModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPT2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPT2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_gpt2(*args, **kwargs): requires_backends(load_tf_weights_in_gpt2, ["torch"])
class GPTBigCodeForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTBigCodeForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTBigCodeForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTBigCodeModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTBigCodePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_gpt_neo(*args, **kwargs): requires_backends(load_tf_weights_in_gpt_neo, ["torch"])
class GPTNeoXForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoXForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoXForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoXForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoXModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoXPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoXJapaneseForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoXJapaneseModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTNeoXJapanesePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTJForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTJForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTJForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTJModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GPTJPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GraniteForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GraniteModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GranitePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GraniteMoeForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GraniteMoeModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GraniteMoePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GroundingDinoForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GroundingDinoModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GroundingDinoPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GroupViTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GroupViTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GroupViTTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class GroupViTVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HieraBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HieraForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HieraForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HieraModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HieraPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HubertForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HubertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HubertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HubertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IBertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IBertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IBertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IBertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IBertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IdeficsForVisionText2Text(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IdeficsModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IdeficsPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class IdeficsProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Idefics2ForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Idefics2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Idefics2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Idefics2Processor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HurLMForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HurLMModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HurLMPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class HurLMProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])    
class ImageGPTForCausalImageModeling(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ImageGPTForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ImageGPTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ImageGPTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_imagegpt(*args, **kwargs): requires_backends(load_tf_weights_in_imagegpt, ["torch"])
class InformerForPrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InstructBlipForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InstructBlipPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InstructBlipQFormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InstructBlipVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InstructBlipVideoForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InstructBlipVideoPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InstructBlipVideoQFormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class InstructBlipVideoVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JambaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JambaForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JambaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JambaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JetMoeForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JetMoeForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JetMoeModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class JetMoePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Kosmos2ForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Kosmos2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Kosmos2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMv2ForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMv2ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMv2ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMv2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMv2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMv3ForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMv3ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMv3ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMv3Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LayoutLMv3PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LEDForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LEDForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LEDForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LEDModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LEDPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LevitForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LevitForImageClassificationWithTeacher(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LevitModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LevitPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LiltForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LiltForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LiltForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LiltModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LiltPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlamaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlamaForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlamaForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlamaForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlamaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlamaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlavaForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlavaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlavaNextForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlavaNextPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlavaNextVideoForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlavaNextVideoPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlavaOnevisionForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LlavaOnevisionPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongformerForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongformerForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongformerForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongformerForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongformerForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongT5EncoderModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongT5ForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongT5Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LongT5PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LukeForEntityClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LukeForEntityPairClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LukeForEntitySpanClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LukeForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LukeForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LukeForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LukeForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LukeForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LukeModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LukePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LxmertEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LxmertForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LxmertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LxmertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LxmertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class LxmertVisualFeatureEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class M2M100ForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class M2M100Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class M2M100PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MambaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MambaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MambaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Mamba2ForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Mamba2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Mamba2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MarianForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MarianModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MarianMTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MarianPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MarkupLMForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MarkupLMForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MarkupLMForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MarkupLMModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MarkupLMPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Mask2FormerForUniversalSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Mask2FormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Mask2FormerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MaskFormerForInstanceSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MaskFormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MaskFormerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MaskFormerSwinBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MBartForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MBartForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MBartForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MBartForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MBartModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MBartPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegatronBertForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegatronBertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegatronBertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegatronBertForNextSentencePrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegatronBertForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegatronBertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegatronBertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegatronBertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegatronBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MegatronBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MgpstrForSceneTextRecognition(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MgpstrModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MgpstrPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MimiModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MimiPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MistralForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MistralForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MistralForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MistralModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MistralPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MixtralForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MixtralForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MixtralForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MixtralModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MixtralPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MllamaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MllamaForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MllamaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MllamaProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MllamaTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MllamaVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileBertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileBertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileBertForNextSentencePrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileBertForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileBertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileBertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileBertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_mobilebert(*args, **kwargs): requires_backends(load_tf_weights_in_mobilebert, ["torch"])
class MobileNetV1ForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileNetV1Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileNetV1PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_mobilenet_v1(*args, **kwargs): requires_backends(load_tf_weights_in_mobilenet_v1, ["torch"])
class MobileNetV2ForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileNetV2ForSemanticSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileNetV2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileNetV2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_mobilenet_v2(*args, **kwargs): requires_backends(load_tf_weights_in_mobilenet_v2, ["torch"])
class MobileViTForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileViTForSemanticSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileViTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileViTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileViTV2ForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileViTV2ForSemanticSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileViTV2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MobileViTV2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ModularEntityForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ModularEntityForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ModularEntityPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ModularEntityProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ModularEntityTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ModularEntityVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MPNetForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MPNetForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MPNetForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MPNetForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MPNetForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MPNetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MPNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MptForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MptForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MptForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MptForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MptModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MptPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MraForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MraForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MraForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MraForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MraForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MraModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MraPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MT5EncoderModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MT5ForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MT5ForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MT5ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MT5ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MT5Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MT5PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MusicgenForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MusicgenForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MusicgenModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MusicgenPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MusicgenProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MusicgenMelodyForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MusicgenMelodyForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MusicgenMelodyModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MusicgenMelodyPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MvpForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MvpForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MvpForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MvpForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MvpModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class MvpPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NemotronForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NemotronForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NemotronForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NemotronForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NemotronModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NemotronPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NllbMoeForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NllbMoeModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NllbMoePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NllbMoeSparseMLP(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NllbMoeTop2Router(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NystromformerForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NystromformerForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NystromformerForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NystromformerForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NystromformerForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NystromformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class NystromformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OlmoForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OlmoModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OlmoPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OlmoeForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OlmoeModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OlmoePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OmDetTurboForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OmDetTurboPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OneFormerForUniversalSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OneFormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OneFormerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OpenAIGPTDoubleHeadsModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OpenAIGPTForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OpenAIGPTLMHeadModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OpenAIGPTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OpenAIGPTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_openai_gpt(*args, **kwargs): requires_backends(load_tf_weights_in_openai_gpt, ["torch"])
class OPTForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OPTForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OPTForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OPTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OPTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Owlv2ForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Owlv2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Owlv2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Owlv2TextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Owlv2VisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OwlViTForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OwlViTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OwlViTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OwlViTTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class OwlViTVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PaliGemmaForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PaliGemmaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PaliGemmaProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSMixerForPrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSMixerForPretraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSMixerForRegression(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSMixerForTimeSeriesClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSMixerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSMixerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSTForClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSTForPrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSTForPretraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSTForRegression(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PatchTSTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PegasusForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PegasusForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PegasusModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PegasusPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PegasusXForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PegasusXModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PegasusXPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PerceiverForImageClassificationConvProcessing(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PerceiverForImageClassificationFourier(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PerceiverForImageClassificationLearned(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PerceiverForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PerceiverForMultimodalAutoencoding(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PerceiverForOpticalFlow(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PerceiverForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PerceiverModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PerceiverPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PersimmonForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PersimmonForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PersimmonForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PersimmonModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PersimmonPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PhiForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PhiForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PhiForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PhiModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PhiPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Phi3ForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Phi3ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Phi3ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Phi3Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Phi3PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Pix2StructForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Pix2StructPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Pix2StructTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Pix2StructVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PixtralPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PixtralVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PLBartForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PLBartForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PLBartForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PLBartModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PLBartPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PoolFormerForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PoolFormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PoolFormerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Pop2PianoForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Pop2PianoPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ProphetNetDecoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ProphetNetEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ProphetNetForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ProphetNetForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ProphetNetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ProphetNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PvtForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PvtModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PvtPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PvtV2Backbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PvtV2ForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PvtV2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class PvtV2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2ForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2AudioEncoder(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2AudioForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2AudioPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2MoeForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2MoeForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2MoeForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2MoeModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2MoePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2VLForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2VLModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Qwen2VLPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RagModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RagPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RagSequenceForGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RagTokenForGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RecurrentGemmaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RecurrentGemmaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RecurrentGemmaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ReformerForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ReformerForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ReformerForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ReformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ReformerModelWithLMHead(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ReformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RegNetForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RegNetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RegNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RemBertForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RemBertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RemBertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RemBertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RemBertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RemBertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RemBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RemBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_rembert(*args, **kwargs): requires_backends(load_tf_weights_in_rembert, ["torch"])
class ResNetBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ResNetForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ResNetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ResNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaPreLayerNormForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaPreLayerNormForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaPreLayerNormForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaPreLayerNormForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaPreLayerNormForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaPreLayerNormForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaPreLayerNormModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RobertaPreLayerNormPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoCBertForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoCBertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoCBertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoCBertForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoCBertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoCBertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoCBertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoCBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoCBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_roc_bert(*args, **kwargs): requires_backends(load_tf_weights_in_roc_bert, ["torch"])
class RoFormerForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoFormerForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoFormerForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoFormerForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoFormerForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoFormerForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoFormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RoFormerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_roformer(*args, **kwargs): requires_backends(load_tf_weights_in_roformer, ["torch"])
class RTDetrForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RTDetrModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RTDetrPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RTDetrResNetBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RTDetrResNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RwkvForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RwkvModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class RwkvPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SamModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SamPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapamaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapamaForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapamaForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapamaForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapamaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapamaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIAudioForAudioClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIAudioForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIAudioForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIAudioModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIAudioPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIImageForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIImagePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicGenForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicGenForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicGenModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicGenPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicGenProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicGenMelodyForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicGenMelodyForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicGenMelodyModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIMusicGenMelodyPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIVideoForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIVideoPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIZeroForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIZeroModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SAPIZeroPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapiensForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapiensForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapiensForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapiensModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapiensPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapiensVisionForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapiensVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SapiensVisionPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SastralForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SastralForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SastralForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SastralModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SastralPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4TCodeHifiGan(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4TForSpeechToSpeech(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4TForSpeechToText(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4TForTextToSpeech(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4TForTextToText(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4THifiGan(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4TModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4TPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4TTextToUnitForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4TTextToUnitModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4Tv2ForSpeechToSpeech(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4Tv2ForSpeechToText(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4Tv2ForTextToSpeech(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4Tv2ForTextToText(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4Tv2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SeamlessM4Tv2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SegformerDecodeHead(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SegformerForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SegformerForSemanticSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SegformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SegformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SegGptForImageSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SegGptModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SegGptPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SEWForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SEWForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SEWModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SEWPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SEWDForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SEWDForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SEWDModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SEWDPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SiglipForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SiglipModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SiglipPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SiglipTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SiglipVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SpeechEncoderDecoderModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Speech2TextForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Speech2TextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Speech2TextPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SpeechT5ForSpeechToSpeech(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SpeechT5ForSpeechToText(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SpeechT5ForTextToSpeech(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SpeechT5HifiGan(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SpeechT5Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SpeechT5PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SplinterForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SplinterForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SplinterModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SplinterPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SqueezeBertForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SqueezeBertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SqueezeBertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SqueezeBertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SqueezeBertForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SqueezeBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SqueezeBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class StableLmForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class StableLmForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class StableLmForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class StableLmModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class StableLmPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Starcoder2ForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Starcoder2ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Starcoder2ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Starcoder2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Starcoder2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SuperPointForKeypointDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SuperPointPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwiftFormerForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwiftFormerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwiftFormerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwinBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwinForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwinForMaskedImageModeling(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwinModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwinPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Swin2SRForImageSuperResolution(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Swin2SRModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Swin2SRPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Swinv2Backbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Swinv2ForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Swinv2ForMaskedImageModeling(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Swinv2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Swinv2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwitchTransformersEncoderModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwitchTransformersForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwitchTransformersModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwitchTransformersPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwitchTransformersSparseMLP(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class SwitchTransformersTop1Router(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class T5EncoderModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class T5ForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class T5ForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class T5ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class T5ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class T5Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class T5PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_t5(*args, **kwargs): requires_backends(load_tf_weights_in_t5, ["torch"])
class TableTransformerForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TableTransformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TableTransformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TapasForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TapasForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TapasForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TapasModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TapasPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_tapas(*args, **kwargs): requires_backends(load_tf_weights_in_tapas, ["torch"])
class TimeSeriesTransformerForPrediction(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TimeSeriesTransformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TimeSeriesTransformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TimesformerForVideoClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TimesformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TimesformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TimmBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TrOCRForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TrOCRPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TvpForVideoGrounding(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TvpModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class TvpPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UdopEncoderModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UdopForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UdopModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UdopPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UMT5EncoderModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UMT5ForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UMT5ForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UMT5ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UMT5ForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UMT5Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UMT5PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechSatForAudioFrameClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechSatForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechSatForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechSatForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechSatForXVector(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechSatModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UniSpeechSatPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UnivNetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UperNetForSemanticSegmentation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class UperNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VideoLlavaForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VideoLlavaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VideoLlavaProcessor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VideoMAEForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VideoMAEForVideoClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VideoMAEModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VideoMAEPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViltForImageAndTextRetrieval(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViltForImagesAndTextClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViltForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViltForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViltForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViltModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViltPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VipLlavaForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VipLlavaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VisionEncoderDecoderModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VisionTextDualEncoderModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VisualBertForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VisualBertForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VisualBertForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VisualBertForRegionToPhraseAlignment(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VisualBertForVisualReasoning(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VisualBertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VisualBertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTForMaskedImageModeling(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTMAEForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTMAEModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTMAEPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTMSNForImageClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTMSNModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ViTMSNPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VitDetBackbone(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VitDetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VitDetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VitMatteForImageMatting(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VitMattePreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VitsModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VitsPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VivitForVideoClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VivitModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class VivitPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ForAudioFrameClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ForXVector(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2Model(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2PreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2BertForAudioFrameClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2BertForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2BertForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2BertForXVector(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2BertModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2BertPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ConformerForAudioFrameClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ConformerForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ConformerForPreTraining(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ConformerForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ConformerForXVector(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ConformerModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Wav2Vec2ConformerPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WavLMForAudioFrameClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WavLMForCTC(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WavLMForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WavLMForXVector(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WavLMModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WavLMPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WhisperForAudioClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WhisperForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WhisperForConditionalGeneration(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WhisperModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class WhisperPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XCLIPModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XCLIPPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XCLIPTextModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XCLIPVisionModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XGLMForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XGLMModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XGLMPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMForQuestionAnsweringSimple(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMWithLMHeadModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaXLForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaXLForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaXLForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaXLForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaXLForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaXLForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaXLModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLMRobertaXLPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLNetForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLNetForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLNetForQuestionAnsweringSimple(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLNetForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLNetForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLNetLMHeadModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLNetModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XLNetPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def load_tf_weights_in_xlnet(*args, **kwargs): requires_backends(load_tf_weights_in_xlnet, ["torch"])
class XmodForCausalLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XmodForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XmodForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XmodForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XmodForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XmodForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XmodModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class XmodPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class YolosForObjectDetection(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class YolosModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class YolosPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class YosoForMaskedLM(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class YosoForMultipleChoice(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class YosoForQuestionAnswering(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class YosoForSequenceClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class YosoForTokenClassification(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class YosoModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class YosoPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ZoeDepthForDepthEstimation(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class ZoeDepthPreTrainedModel(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class Adafactor(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
class AdamW(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def get_constant_schedule(*args, **kwargs): requires_backends(get_constant_schedule, ["torch"])
def get_constant_schedule_with_warmup(*args, **kwargs): requires_backends(get_constant_schedule_with_warmup, ["torch"])
def get_cosine_schedule_with_warmup(*args, **kwargs): requires_backends(get_cosine_schedule_with_warmup, ["torch"])
def get_cosine_with_hard_restarts_schedule_with_warmup(*args, **kwargs): requires_backends(get_cosine_with_hard_restarts_schedule_with_warmup, ["torch"])
def get_inverse_sqrt_schedule(*args, **kwargs): requires_backends(get_inverse_sqrt_schedule, ["torch"])
def get_linear_schedule_with_warmup(*args, **kwargs): requires_backends(get_linear_schedule_with_warmup, ["torch"])
def get_polynomial_decay_schedule_with_warmup(*args, **kwargs): requires_backends(get_polynomial_decay_schedule_with_warmup, ["torch"])
def get_scheduler(*args, **kwargs): requires_backends(get_scheduler, ["torch"])
def get_wsd_schedule(*args, **kwargs): requires_backends(get_wsd_schedule, ["torch"])
class Conv1D(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def apply_chunking_to_forward(*args, **kwargs): requires_backends(apply_chunking_to_forward, ["torch"])
def prune_layer(*args, **kwargs): requires_backends(prune_layer, ["torch"])
class Trainer(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
def torch_distributed_zero_first(*args, **kwargs): requires_backends(torch_distributed_zero_first, ["torch"])
class Seq2SeqTrainer(metaclass=DummyObject):
    _backends = ["torch"]
    def __init__(self, *args, **kwargs): requires_backends(self, ["torch"])
"""
    #################################################################################################################################################################################################
    # This code library is an adaptation of the original Transformers and was designed, developed and programmed by Sapiens Technology®.                                                            #
    # Any alteration and/or disclosure of this code without prior authorization is strictly prohibited and is subject to legal action that will be forwarded by the Sapiens Technology® legal team. #
    # This set of algorithms aims to download, train, fine-tune and/or infer large language models from various sources and slopes.                                                                 #
    #################################################################################################################################################################################################
"""
