.\utils\dummy_sentencepiece_and_tokenizers_objects.py
# 这个文件是通过命令 `make fix-copies` 自动生成的,不要编辑。
# 从上层模块导入 DummyObject 和 requires_backends 函数
from ..utils import DummyObject, requires_backends
# 初始化一个全局变量 SLOW_TO_FAST_CONVERTERS,暂时设为 None
SLOW_TO_FAST_CONVERTERS = None
# 定义一个函数 convert_slow_tokenizer,用于将慢速分词器转换为快速分词器
# 该函数使用 requires_backends 函数确保运行时有必要的后端支持模块 ["sentencepiece", "tokenizers"]
def convert_slow_tokenizer(*args, **kwargs):
requires_backends(convert_slow_tokenizer, ["sentencepiece", "tokenizers"])
.\utils\dummy_sentencepiece_objects.py
# 以下代码由命令 `make fix-copies` 自动生成,不要修改。
from ..utils import DummyObject, requires_backends
# 定义 AlbertTokenizer 类,使用 DummyObject 元类
class AlbertTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 BarthezTokenizer 类,使用 DummyObject 元类
class BarthezTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 BartphoTokenizer 类,使用 DummyObject 元类
class BartphoTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 BertGenerationTokenizer 类,使用 DummyObject 元类
class BertGenerationTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 BigBirdTokenizer 类,使用 DummyObject 元类
class BigBirdTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 CamembertTokenizer 类,使用 DummyObject 元类
class CamembertTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 CodeLlamaTokenizer 类,使用 DummyObject 元类
class CodeLlamaTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 CpmTokenizer 类,使用 DummyObject 元类
class CpmTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 DebertaV2Tokenizer 类,使用 DummyObject 元类
class DebertaV2Tokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 ErnieMTokenizer 类,使用 DummyObject 元类
class ErnieMTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 FNetTokenizer 类,使用 DummyObject 元类
class FNetTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 GemmaTokenizer 类,使用 DummyObject 元类
class GemmaTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 GPTSw3Tokenizer 类,使用 DummyObject 元类
class GPTSw3Tokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 LayoutXLMTokenizer 类,使用 DummyObject 元类
class LayoutXLMTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 LlamaTokenizer 类,使用 DummyObject 元类
class LlamaTokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 M2M100Tokenizer 类,使用 DummyObject 元类
class M2M100Tokenizer(metaclass=DummyObject):
# 定义支持的后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 要求当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义 MarianTokenizer 类,使用 DummyObject 元类
class MarianTokenizer(metaclass=DummyObject):
# 该类的定义未完整,暂无初始化方法和后端定义
pass
# 定义一个类属性 `_backends`,该列表包含字符串 "sentencepiece"
_backends = ["sentencepiece"]
# 定义类的初始化方法 `__init__`,接受任意数量的位置参数 `args` 和关键字参数 `kwargs`
def __init__(self, *args, **kwargs):
# 调用 `requires_backends` 函数,传入当前对象以及要求的后端列表 ["sentencepiece"]
requires_backends(self, ["sentencepiece"])
# 定义一个 MBart50Tokenizer 类,使用 DummyObject 元类
class MBart50Tokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 MBartTokenizer 类,使用 DummyObject 元类
class MBartTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 MLukeTokenizer 类,使用 DummyObject 元类
class MLukeTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 MT5Tokenizer 类,使用 DummyObject 元类
class MT5Tokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 NllbTokenizer 类,使用 DummyObject 元类
class NllbTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 PegasusTokenizer 类,使用 DummyObject 元类
class PegasusTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 PLBartTokenizer 类,使用 DummyObject 元类
class PLBartTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 ReformerTokenizer 类,使用 DummyObject 元类
class ReformerTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 RemBertTokenizer 类,使用 DummyObject 元类
class RemBertTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 SeamlessM4TTokenizer 类,使用 DummyObject 元类
class SeamlessM4TTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 SiglipTokenizer 类,使用 DummyObject 元类
class SiglipTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 Speech2TextTokenizer 类,使用 DummyObject 元类
class Speech2TextTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 SpeechT5Tokenizer 类,使用 DummyObject 元类
class SpeechT5Tokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 T5Tokenizer 类,使用 DummyObject 元类
class T5Tokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 UdopTokenizer 类,使用 DummyObject 元类
class UdopTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 XGLMTokenizer 类,使用 DummyObject 元类
class XGLMTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖 "sentencepiece" 后端
requires_backends(self, ["sentencepiece"])
# 定义一个 XLMProphetNetTokenizer 类,使用 DummyObject 元类
class XLMProphetNetTokenizer(metaclass=DummyObject):
# 类变量,指定后端为 "sentencepiece"
_backends = ["sentencepiece"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
#
# 定义 XLMRobertaTokenizer 类,使用 DummyObject 元类
class XLMRobertaTokenizer(metaclass=DummyObject):
# 类变量 _back
.\utils\dummy_speech_objects.py
# 这个文件是由命令 `make fix-copies` 自动生成的,不要编辑。
# 从上级目录的 utils 模块中导入 DummyObject 和 requires_backends 函数
from ..utils import DummyObject, requires_backends
# 定义一个元类为 DummyObject 的类 ASTFeatureExtractor
class ASTFeatureExtractor(metaclass=DummyObject):
# 类属性 _backends,指定为包含字符串 "speech" 的列表
_backends = ["speech"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保 self 对象依赖 "speech" 后端
requires_backends(self, ["speech"])
# 定义一个元类为 DummyObject 的类 Speech2TextFeatureExtractor
class Speech2TextFeatureExtractor(metaclass=DummyObject):
# 类属性 _backends,指定为包含字符串 "speech" 的列表
_backends = ["speech"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保 self 对象依赖 "speech" 后端
requires_backends(self, ["speech"])
.\utils\dummy_tensorflow_text_objects.py
# 该文件由命令 `make fix-copies` 自动生成,不要编辑。
# 从上级目录的 utils 模块导入 DummyObject 和 requires_backends 函数
from ..utils import DummyObject, requires_backends
# 定义 TFBertTokenizer 类,其元类为 DummyObject
class TFBertTokenizer(metaclass=DummyObject):
# _backends 属性指定为 ["tensorflow_text"]
_backends = ["tensorflow_text"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖于 "tensorflow_text" 后端
requires_backends(self, ["tensorflow_text"])
.\utils\dummy_tf_objects.py
# 由命令 `make fix-copies` 自动生成的文件,不要手动编辑。
from ..utils import DummyObject, requires_backends
# 定义一个元类为 DummyObject 的类 TensorFlowBenchmarkArguments,该类支持 TensorFlow 后端
class TensorFlowBenchmarkArguments(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TensorFlowBenchmark,该类支持 TensorFlow 后端
class TensorFlowBenchmark(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFForcedBOSTokenLogitsProcessor,该类支持 TensorFlow 后端
class TFForcedBOSTokenLogitsProcessor(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFForcedEOSTokenLogitsProcessor,该类支持 TensorFlow 后端
class TFForcedEOSTokenLogitsProcessor(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFForceTokensLogitsProcessor,该类支持 TensorFlow 后端
class TFForceTokensLogitsProcessor(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFGenerationMixin,该类支持 TensorFlow 后端
class TFGenerationMixin(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFLogitsProcessor,该类支持 TensorFlow 后端
class TFLogitsProcessor(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFLogitsProcessorList,该类支持 TensorFlow 后端
class TFLogitsProcessorList(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFLogitsWarper,该类支持 TensorFlow 后端
class TFLogitsWarper(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFMinLengthLogitsProcessor,该类支持 TensorFlow 后端
class TFMinLengthLogitsProcessor(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFNoBadWordsLogitsProcessor,该类支持 TensorFlow 后端
class TFNoBadWordsLogitsProcessor(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFNoRepeatNGramLogitsProcessor,该类支持 TensorFlow 后端
class TFNoRepeatNGramLogitsProcessor(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFRepetitionPenaltyLogitsProcessor,该类支持 TensorFlow 后端
class TFRepetitionPenaltyLogitsProcessor(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFSuppressTokensAtBeginLogitsProcessor,该类支持 TensorFlow 后端
class TFSuppressTokensAtBeginLogitsProcessor(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFSuppressTokensLogitsProcessor,该类支持 TensorFlow 后端
class TFSuppressTokensLogitsProcessor(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFTemperatureLogitsWarper,该类支持 TensorFlow 后端
class TFTemperatureLogitsWarper(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFTopKLogitsWarper,该类支持 TensorFlow 后端
class TFTopKLogitsWarper(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,并要求依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个元类为 DummyObject 的类 TFTopPLogitsWarper,该类支持 TensorFlow 后端
class TFTopPLogitsWarper(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,接受任意参数,没有要求依赖的 TensorFlow 后端
def __init__(self, *args, **kwargs):
pass
# 初始化函数,用于实例化对象时执行初始化操作
def __init__(self, *args, **kwargs):
# 要求确保对象支持 TensorFlow 后端
requires_backends(self, ["tf"])
class KerasMetricCallback(metaclass=DummyObject):
# 使用DummyObject作为元类创建KerasMetricCallback类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class PushToHubCallback(metaclass=DummyObject):
# 使用DummyObject作为元类创建PushToHubCallback类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFPreTrainedModel(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFPreTrainedModel类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFSequenceSummary(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFSequenceSummary类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFSharedEmbeddings(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFSharedEmbeddings类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
def shape_list(*args, **kwargs):
# 要求shape_list函数的后端为TensorFlow
requires_backends(shape_list, ["tf"])
TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFAlbertForMaskedLM(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFAlbertForMaskedLM类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFAlbertForMultipleChoice(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFAlbertForMultipleChoice类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFAlbertForPreTraining(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFAlbertForPreTraining类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFAlbertForQuestionAnswering(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFAlbertForQuestionAnswering类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFAlbertForSequenceClassification(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFAlbertForSequenceClassification类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFAlbertForTokenClassification(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFAlbertForTokenClassification类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFAlbertMainLayer(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFAlbertMainLayer类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFAlbertModel(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFAlbertModel类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
class TFAlbertPreTrainedModel(metaclass=DummyObject):
# 使用DummyObject作为元类创建TFAlbertPreTrainedModel类,这是一个空占位符类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求该实例的后端为TensorFlow
requires_backends(self, ["tf"])
TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING = None
TF_MODEL_FOR_CAUSAL_LM_MAPPING = None
TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING = None
TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING = None
TF_MODEL_FOR_MASK_GENERATION_MAPPING = None
TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING = None
TF_MODEL_FOR_MASKED_LM_MAPPING = None
TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING = None
TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING = None
TF_MODEL_FOR_PRETRAINING_MAPPING = None
TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING = None
TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING = None
TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING = None
# 定义 TensorFlow 模型到序列分类的映射,初始值为 None
TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING = None
# 定义 TensorFlow 模型到语音序列到序列的映射,初始值为 None
TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING = None
# 定义 TensorFlow 模型到表格问答的映射,初始值为 None
TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING = None
# 定义 TensorFlow 模型到文本编码的映射,初始值为 None
TF_MODEL_FOR_TEXT_ENCODING_MAPPING = None
# 定义 TensorFlow 模型到标记分类的映射,初始值为 None
TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING = None
# 定义 TensorFlow 模型到视觉序列到序列的映射,初始值为 None
TF_MODEL_FOR_VISION_2_SEQ_MAPPING = None
# 定义 TensorFlow 模型到零样本图像分类的映射,初始值为 None
TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING = None
# 定义 TensorFlow 模型的映射,初始值为 None
TF_MODEL_MAPPING = None
# 定义 TensorFlow 模型带有语言模型头的映射,初始值为 None
TF_MODEL_WITH_LM_HEAD_MAPPING = None
# 定义 TFAutoModel 类,用于自动化创建 TensorFlow 模型
class TFAutoModel(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForAudioClassification 类,用于自动化创建音频分类的 TensorFlow 模型
class TFAutoModelForAudioClassification(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForCausalLM 类,用于自动化创建因果语言模型的 TensorFlow 模型
class TFAutoModelForCausalLM(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForDocumentQuestionAnswering 类,用于自动化创建文档问答的 TensorFlow 模型
class TFAutoModelForDocumentQuestionAnswering(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForImageClassification 类,用于自动化创建图像分类的 TensorFlow 模型
class TFAutoModelForImageClassification(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForMaskedImageModeling 类,用于自动化创建遮蔽图像建模的 TensorFlow 模型
class TFAutoModelForMaskedImageModeling(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForMaskedLM 类,用于自动化创建遮蔽语言模型的 TensorFlow 模型
class TFAutoModelForMaskedLM(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForMaskGeneration 类,用于自动化创建遮蔽生成的 TensorFlow 模型
class TFAutoModelForMaskGeneration(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForMultipleChoice 类,用于自动化创建多项选择的 TensorFlow 模型
class TFAutoModelForMultipleChoice(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForNextSentencePrediction 类,用于自动化创建下一句预测的 TensorFlow 模型
class TFAutoModelForNextSentencePrediction(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForPreTraining 类,用于自动化创建预训练的 TensorFlow 模型
class TFAutoModelForPreTraining(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForQuestionAnswering 类,用于自动化创建问答的 TensorFlow 模型
class TFAutoModelForQuestionAnswering(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForSemanticSegmentation 类,用于自动化创建语义分割的 TensorFlow 模型
class TFAutoModelForSemanticSegmentation(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForSeq2SeqLM 类,用于自动化创建序列到序列语言模型的 TensorFlow 模型
class TFAutoModelForSeq2SeqLM(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForSequenceClassification 类,用于自动化创建序列分类的 TensorFlow 模型
class TFAutoModelForSequenceClassification(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类实例化时依赖 TensorFlow 后端
requires_backends(self, ["tf"])
# 定义 TFAutoModelForSpeechSeq2Seq 类,用于自动化创建语音序列到序列的 TensorFlow 模型
class TFAutoModelForSpeechSeq2Seq(metaclass=DummyObject):
# 支持的后端为 TensorFlow
_backends = ["tf"]
# 注意:此类定义未完,需要根据实际内容继续补
# 定义类的类变量 _backends,指定支持的后端为 "tf"
_backends = ["tf"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用函数 requires_backends 来确保当前类实例支持 "tf" 后端
requires_backends(self, ["tf"])
class TFAutoModelForTableQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFAutoModelForTextEncoding(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFAutoModelForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFAutoModelForVision2Seq(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFAutoModelForZeroShotImageClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFAutoModelWithLMHead(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBartForConditionalGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBartForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBartModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBartPretrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFBertEmbeddings(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBertForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBertForMultipleChoice(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBertForNextSentencePrediction(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBertForPreTraining(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBertForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBertForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBertForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保当前类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFBertLMHeadModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBertLMHeadModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBertMainLayer(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBertMainLayer 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBertModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBertModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBertPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBertPreTrainedModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlenderbotForConditionalGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlenderbotForConditionalGeneration 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlenderbotModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlenderbotModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlenderbotPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlenderbotPreTrainedModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlenderbotSmallForConditionalGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlenderbotSmallForConditionalGeneration 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlenderbotSmallModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlenderbotSmallModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlenderbotSmallPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlenderbotSmallPreTrainedModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFBlipForConditionalGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlipForConditionalGeneration 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlipForImageTextRetrieval(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlipForImageTextRetrieval 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlipForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlipForQuestionAnswering 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlipModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlipModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlipPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlipPreTrainedModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlipTextModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlipTextModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
class TFBlipVisionModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFBlipVisionModel 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
TF_CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFCamembertForCausalLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建 TFCamembertForCausalLM 类,确保仅兼容 "tf" 后端
requires_backends(self, ["tf"])
# 定义 TFCamembertForMaskedLM 类,用于 TF 后端的 Masked LM 模型
class TFCamembertForMaskedLM(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFCamembertForMultipleChoice 类,用于 TF 后端的多选题模型
class TFCamembertForMultipleChoice(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFCamembertForQuestionAnswering 类,用于 TF 后端的问答模型
class TFCamembertForQuestionAnswering(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFCamembertForSequenceClassification 类,用于 TF 后端的序列分类模型
class TFCamembertForSequenceClassification(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFCamembertForTokenClassification 类,用于 TF 后端的标记分类模型
class TFCamembertForTokenClassification(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFCamembertModel 类,用于 TF 后端的 Camembert 模型
class TFCamembertModel(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFCamembertPreTrainedModel 类,用于 TF 后端的预训练 Camembert 模型
class TFCamembertPreTrainedModel(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST 为 None
TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义 TFCLIPModel 类,用于 TF 后端的 CLIP 模型
class TFCLIPModel(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFCLIPPreTrainedModel 类,用于 TF 后端的预训练 CLIP 模型
class TFCLIPPreTrainedModel(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFCLIPTextModel 类,用于 TF 后端的文本 CLIP 模型
class TFCLIPTextModel(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFCLIPVisionModel 类,用于 TF 后端的视觉 CLIP 模型
class TFCLIPVisionModel(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST 为 None
TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义 TFConvBertForMaskedLM 类,用于 TF 后端的 ConvBERT Masked LM 模型
class TFConvBertForMaskedLM(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFConvBertForMultipleChoice 类,用于 TF 后端的 ConvBERT 多选题模型
class TFConvBertForMultipleChoice(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFConvBertForQuestionAnswering 类,用于 TF 后端的 ConvBERT 问答模型
class TFConvBertForQuestionAnswering(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFConvBertForSequenceClassification 类,用于 TF 后端的 ConvBERT 序列分类模型
class TFConvBertForSequenceClassification(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFConvBertForTokenClassification 类,用于 TF 后端的 ConvBERT 标记分类模型
class TFConvBertForTokenClassification(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFConvBertLayer 类,用于 TF 后端的 ConvBERT 层
class TFConvBertLayer(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,确保依赖的后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义 TFConvBertModel 类,用于 TF 后端的 ConvBERT 模型
class TFConvBertModel(metaclass=DummyObject):
# 指定支持的后端为 TensorFlow
_backends = ["tf"]
# 定义初始化方法,用于类的实例化
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,检查当前类实例是否依赖于 "tf" 这个后端
requires_backends(self, ["tf"])
class TFConvBertPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFConvBertPreTrainedModel 类,要求使用 TensorFlow 后端
class TFConvNextForImageClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFConvNextForImageClassification 类,要求使用 TensorFlow 后端
class TFConvNextModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFConvNextModel 类,要求使用 TensorFlow 后端
class TFConvNextPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFConvNextPreTrainedModel 类,要求使用 TensorFlow 后端
class TFConvNextV2ForImageClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFConvNextV2ForImageClassification 类,要求使用 TensorFlow 后端
class TFConvNextV2Model(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFConvNextV2Model 类,要求使用 TensorFlow 后端
class TFConvNextV2PreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFConvNextV2PreTrainedModel 类,要求使用 TensorFlow 后端
TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST = None
# TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST 设置为 None
class TFCTRLForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFCTRLForSequenceClassification 类,要求使用 TensorFlow 后端
class TFCTRLLMHeadModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFCTRLLMHeadModel 类,要求使用 TensorFlow 后端
class TFCTRLModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFCTRLModel 类,要求使用 TensorFlow 后端
class TFCTRLPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFCTRLPreTrainedModel 类,要求使用 TensorFlow 后端
TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST = None
# TF_CVT_PRETRAINED_MODEL_ARCHIVE_LIST 设置为 None
class TFCvtForImageClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFCvtForImageClassification 类,要求使用 TensorFlow 后端
class TFCvtModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFCvtModel 类,要求使用 TensorFlow 后端
class TFCvtPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFCvtPreTrainedModel 类,要求使用 TensorFlow 后端
class TFData2VecVisionForImageClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFData2VecVisionForImageClassification 类,要求使用 TensorFlow 后端
class TFData2VecVisionForSemanticSegmentation(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFData2VecVisionForSemanticSegmentation 类,要求使用 TensorFlow 后端
class TFData2VecVisionModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化 TFData2VecVisionModel 类,要求使用 TensorFlow 后端
class TFData2VecVisionPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
# 初始化 TFData2VecVisionPreTrainedModel 类,要求使用 TensorFlow 后端
# 初始化方法,用于实例化对象时的初始化操作
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖了 "tf"(TensorFlow)后端
requires_backends(self, ["tf"])
# 初始化变量,用于存储 TF Deberta 预训练模型的存档列表,目前为空
TF_DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义 TFDebertaForMaskedLM 类,作为 TFDeberta 的Masked Language Model 的接口,使用 DummyObject 元类
class TFDebertaForMaskedLM(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaForMaskedLM 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaForQuestionAnswering 类,作为 TFDeberta 的Question Answering 模型的接口,使用 DummyObject 元类
class TFDebertaForQuestionAnswering(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaForQuestionAnswering 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaForSequenceClassification 类,作为 TFDeberta 的Sequence Classification 模型的接口,使用 DummyObject 元类
class TFDebertaForSequenceClassification(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaForSequenceClassification 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaForTokenClassification 类,作为 TFDeberta 的Token Classification 模型的接口,使用 DummyObject 元类
class TFDebertaForTokenClassification(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaForTokenClassification 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaModel 类,作为 TFDeberta 的基础模型接口,使用 DummyObject 元类
class TFDebertaModel(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaModel 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaPreTrainedModel 类,作为 TFDeberta 的预训练模型的接口,使用 DummyObject 元类
class TFDebertaPreTrainedModel(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaPreTrainedModel 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 初始化变量,用于存储 TF Deberta V2 预训练模型的存档列表,目前为空
TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义 TFDebertaV2ForMaskedLM 类,作为 TFDeberta V2 的Masked Language Model 的接口,使用 DummyObject 元类
class TFDebertaV2ForMaskedLM(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaV2ForMaskedLM 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaV2ForMultipleChoice 类,作为 TFDeberta V2 的Multiple Choice 模型的接口,使用 DummyObject 元类
class TFDebertaV2ForMultipleChoice(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaV2ForMultipleChoice 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaV2ForQuestionAnswering 类,作为 TFDeberta V2 的Question Answering 模型的接口,使用 DummyObject 元类
class TFDebertaV2ForQuestionAnswering(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaV2ForQuestionAnswering 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaV2ForSequenceClassification 类,作为 TFDeberta V2 的Sequence Classification 模型的接口,使用 DummyObject 元类
class TFDebertaV2ForSequenceClassification(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaV2ForSequenceClassification 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaV2ForTokenClassification 类,作为 TFDeberta V2 的Token Classification 模型的接口,使用 DummyObject 元类
class TFDebertaV2ForTokenClassification(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaV2ForTokenClassification 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaV2Model 类,作为 TFDeberta V2 的基础模型接口,使用 DummyObject 元类
class TFDebertaV2Model(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaV2Model 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDebertaV2PreTrainedModel 类,作为 TFDeberta V2 的预训练模型的接口,使用 DummyObject 元类
class TFDebertaV2PreTrainedModel(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDebertaV2PreTrainedModel 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 初始化变量,用于存储 TF DeiT 预训练模型的存档列表,目前为空
TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义 TFDeiTForImageClassification 类,作为 TFDeiT 的Image Classification 模型的接口,使用 DummyObject 元类
class TFDeiTForImageClassification(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDeiTForImageClassification 实例
def __init__(self, *args, **kwargs):
# 要求依赖后端为 TensorFlow
requires_backends(self, ["tf"])
# 定义 TFDeiTForImageClassificationWithTeacher 类,作为 TFDeiT 的Image Classification With Teacher 模型的接口,使用 DummyObject 元类
class TFDeiTForImageClassificationWithTeacher(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,用于创建 TFDeiTForImageClassificationWithTeacher 实例
def
# 定义私有类变量 `_backends`,包含字符串 "tf",表示该类依赖 TensorFlow 后端
_backends = ["tf"]
# 类的初始化方法,用于实例化对象时调用
def __init__(self, *args, **kwargs):
# 调用 `requires_backends` 函数,验证当前对象依赖的后端是否包含 "tf"
requires_backends(self, ["tf"])
TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 初始化一个全局变量,用于存储 TFTransfoXL 模型的预训练模型存档列表,初始值为 None
class TFAdaptiveEmbedding(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFAdaptiveEmbedding 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFAdaptiveEmbedding 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFTransfoXLForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFTransfoXLForSequenceClassification 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFTransfoXLForSequenceClassification 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFTransfoXLLMHeadModel(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFTransfoXLLMHeadModel 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFTransfoXLLMHeadModel 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFTransfoXLMainLayer(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFTransfoXLMainLayer 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFTransfoXLMainLayer 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFTransfoXLModel(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFTransfoXLModel 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFTransfoXLModel 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFTransfoXLPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFTransfoXLPreTrainedModel 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFTransfoXLPreTrainedModel 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 初始化一个全局变量,用于存储 TFDistilBert 模型的预训练模型存档列表,初始值为 None
class TFDistilBertForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFDistilBertForMaskedLM 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFDistilBertForMaskedLM 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFDistilBertForMultipleChoice(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFDistilBertForMultipleChoice 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFDistilBertForMultipleChoice 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFDistilBertForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFDistilBertForQuestionAnswering 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFDistilBertForQuestionAnswering 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFDistilBertForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFDistilBertForSequenceClassification 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFDistilBertForSequenceClassification 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFDistilBertForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFDistilBertForTokenClassification 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFDistilBertForTokenClassification 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFDistilBertMainLayer(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFDistilBertMainLayer 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFDistilBertMainLayer 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFDistilBertModel(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFDistilBertModel 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFDistilBertModel 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFDistilBertPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFDistilBertPreTrainedModel 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFDistilBertPreTrainedModel 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 初始化一个全局变量,用于存储 TFDPRContextEncoder 模型的预训练模型存档列表,初始值为 None
TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 初始化一个全局变量,用于存储 TFDPRQuestionEncoder 模型的预训练模型存档列表,初始值为 None
TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 初始化一个全局变量,用于存储 TFDPRReader 模型的预训练模型存档列表,初始值为 None
class TFDPRContextEncoder(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFDPRContextEncoder 类,指定其支持的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化 TFDPRContextEncoder 实例
requires_backends(self, ["tf"])
# 调用函数确保当前实例依赖的后端为 TensorFlow
class TFDPRPretrainedContextEncoder(metaclass=DummyObject):
_backends = ["tf"]
# 定义 TFDPRPretrainedContextEncoder 类,指定其支持的后端为 TensorFlow
# 初始化函数,用于对象的初始化操作
def __init__(self, *args, **kwargs):
# 调用函数 requires_backends 来检查当前对象是否需要特定的后端支持,这里要求支持 "tf" 后端
requires_backends(self, ["tf"])
class TFDPRPretrainedReader(metaclass=DummyObject):
# 定义一个名为 TFDPRPretrainedReader 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFDPRQuestionEncoder(metaclass=DummyObject):
# 定义一个名为 TFDPRQuestionEncoder 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFDPRReader(metaclass=DummyObject):
# 定义一个名为 TFDPRReader 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFEfficientFormerForImageClassification(metaclass=DummyObject):
# 定义一个名为 TFEfficientFormerForImageClassification 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFEfficientFormerForImageClassificationWithTeacher(metaclass=DummyObject):
# 定义一个名为 TFEfficientFormerForImageClassificationWithTeacher 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFEfficientFormerModel(metaclass=DummyObject):
# 定义一个名为 TFEfficientFormerModel 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFEfficientFormerPreTrainedModel(metaclass=DummyObject):
# 定义一个名为 TFEfficientFormerPreTrainedModel 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFElectraForMaskedLM(metaclass=DummyObject):
# 定义一个名为 TFElectraForMaskedLM 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFElectraForMultipleChoice(metaclass=DummyObject):
# 定义一个名为 TFElectraForMultipleChoice 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFElectraForPreTraining(metaclass=DummyObject):
# 定义一个名为 TFElectraForPreTraining 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFElectraForQuestionAnswering(metaclass=DummyObject):
# 定义一个名为 TFElectraForQuestionAnswering 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFElectraForSequenceClassification(metaclass=DummyObject):
# 定义一个名为 TFElectraForSequenceClassification 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFElectraForTokenClassification(metaclass=DummyObject):
# 定义一个名为 TFElectraForTokenClassification 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFElectraModel(metaclass=DummyObject):
# 定义一个名为 TFElectraModel 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFElectraPreTrainedModel(metaclass=DummyObject):
# 定义一个名为 TFElectraPreTrainedModel 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFEncoderDecoderModel(metaclass=DummyObject):
# 定义一个名为 TFEncoderDecoderModel 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
ESM_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFEsmForMaskedLM(metaclass=DummyObject):
# 定义一个名为 TFEsmForMaskedLM 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFEsmForSequenceClassification(metaclass=DummyObject):
# 定义一个名为 TFEsmForSequenceClassification 的类,该类使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,要求该类依赖于 "tf" 后端
requires_backends(self, ["tf"])
# 定义私有属性_backends,值为列表["tf"]
_backends = ["tf"]
# 初始化函数,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用requires_backends函数,检查当前对象是否需要后端"tf"
requires_backends(self, ["tf"])
class TFEsmForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFEsmModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFEsmPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFFlaubertForMultipleChoice(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFlaubertForQuestionAnsweringSimple(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFlaubertForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFlaubertForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFlaubertModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFlaubertPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFlaubertWithLMHeadModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
TF_FUNNEL_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFFunnelBaseModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFunnelForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFunnelForMultipleChoice(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFunnelForPreTraining(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFunnelForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFunnelForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFunnelForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类仅支持 TensorFlow 后端
requires_backends(self, ["tf"])
class TFFunnelModel(metaclass=DummyObject):
_backends = ["tf"]
# 定义初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用函数检查是否需要特定的后端库,这里需要检查 TensorFlow 后端
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFFunnelPreTrainedModel 类,表示 TensorFlow 下的预训练模型
class TFFunnelPreTrainedModel(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST 被设置为 None
TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 使用 DummyObject 元类定义 TFGPT2DoubleHeadsModel 类,表示 TensorFlow 下的 GPT-2 双头模型
class TFGPT2DoubleHeadsModel(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGPT2ForSequenceClassification 类,表示 TensorFlow 下的 GPT-2 序列分类模型
class TFGPT2ForSequenceClassification(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGPT2LMHeadModel 类,表示 TensorFlow 下的 GPT-2 语言模型
class TFGPT2LMHeadModel(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGPT2MainLayer 类,表示 TensorFlow 下的 GPT-2 主层
class TFGPT2MainLayer(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGPT2Model 类,表示 TensorFlow 下的 GPT-2 模型
class TFGPT2Model(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGPT2PreTrainedModel 类,表示 TensorFlow 下的 GPT-2 预训练模型
class TFGPT2PreTrainedModel(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGPTJForCausalLM 类,表示 TensorFlow 下的 GPT-J 因果语言模型
class TFGPTJForCausalLM(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGPTJForQuestionAnswering 类,表示 TensorFlow 下的 GPT-J 问答模型
class TFGPTJForQuestionAnswering(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGPTJForSequenceClassification 类,表示 TensorFlow 下的 GPT-J 序列分类模型
class TFGPTJForSequenceClassification(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGPTJModel 类,表示 TensorFlow 下的 GPT-J 模型
class TFGPTJModel(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGPTJPreTrainedModel 类,表示 TensorFlow 下的 GPT-J 预训练模型
class TFGPTJPreTrainedModel(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# TF_GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST 被设置为 None
TF_GROUPVIT_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 使用 DummyObject 元类定义 TFGroupViTModel 类,表示 TensorFlow 下的 GroupViT 模型
class TFGroupViTModel(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGroupViTPreTrainedModel 类,表示 TensorFlow 下的 GroupViT 预训练模型
class TFGroupViTPreTrainedModel(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGroupViTTextModel 类,表示 TensorFlow 下的 GroupViT 文本模型
class TFGroupViTTextModel(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 使用 DummyObject 元类定义 TFGroupViTVisionModel 类,表示 TensorFlow 下的 GroupViT 视觉模型
class TFGroupViTVisionModel(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任意位置和关键字参数,并确保依赖于 TensorFlow 后端
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST 被设置为 None
TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 使用 DummyObject 元类定义 TFHubertForCTC 类,表示 TensorFlow 下的 Hubert CTC 模型
class TFHubertForCTC(metaclass=DummyObject):
# 类属性,指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,接受任
class TFHubertPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFLayoutLMForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLayoutLMForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLayoutLMForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLayoutLMForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLayoutLMMainLayer(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLayoutLMModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLayoutLMPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFLayoutLMv3ForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLayoutLMv3ForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLayoutLMv3ForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLayoutLMv3Model(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLayoutLMv3PreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLEDForConditionalGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLEDModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLEDPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
TF_LONGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFLongformerForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求此类使用 TensorFlow 作为后端
requires_backends(self, ["tf"])
class TFLongformerForMultipleChoice(metaclass=DummyObject):
# DummyObject类的一个元类,用于模拟一个空的类定义
_backends = ["tf"]
# 定义一个类变量 `_backends`,用于存储支持的后端类型,这里包含了字符串 "tf"
_backends = ["tf"]
# 初始化方法,用于创建类的实例。接受任意位置参数和关键字参数。
def __init__(self, *args, **kwargs):
# 调用 `requires_backends` 函数,确保当前对象依赖于后端类型 "tf",否则会引发错误。
requires_backends(self, ["tf"])
class TFLongformerForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 Longformer 问答模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFLongformerForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 Longformer 序列分类模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFLongformerForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 Longformer 标记分类模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFLongformerModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 Longformer 模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFLongformerPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 Longformer 预训练模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFLongformerSelfAttention(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 Longformer 自注意力模块的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFLxmertForPreTraining(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 LXMERT 预训练模型(用于预训练)的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFLxmertMainLayer(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 LXMERT 主层的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFLxmertModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 LXMERT 模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFLxmertPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 LXMERT 预训练模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFLxmertVisualFeatureEncoder(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 LXMERT 视觉特征编码器的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFMarianModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 Marian 模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFMarianMTModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 Marian 机器翻译模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFMarianPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 Marian 预训练模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFMBartForConditionalGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 MBart 生成式模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFMBartModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 MBart 模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFMBartPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 MBart 预训练模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFMobileBertForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化函数,用于设置 MobileBERT 掩码语言模型的实例。
# 使用 requires_backends 函数确保需要的后端是 TensorFlow。
class TFMobileBertForMultipleChoice(metaclass=DummyObject):
# 定义 TFMobileBertForMultipleChoice 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保当前实例支持 "tf" 后端
class TFMobileBertForNextSentencePrediction(metaclass=DummyObject):
# 定义 TFMobileBertForNextSentencePrediction 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保当前实例支持 "tf" 后端
class TFMobileBertForPreTraining(metaclass=DummyObject):
# 定义 TFMobileBertForPreTraining 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保当前实例支持 "tf" 后端
class TFMobileBertForQuestionAnswering(metaclass=DummyObject):
# 定义 TFMobileBertForQuestionAnswering 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保当前实例支持 "tf" 后端
class TFMobileBertForSequenceClassification(metaclass=DummyObject):
# 定义 TFMobileBertForSequenceClassification 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保当前实例支持 "tf" 后端
class TFMobileBertForTokenClassification(metaclass=DummyObject):
# 定义 TFMobileBertForTokenClassification 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
class TFMobileBertMainLayer(metaclass=DummyObject):
# 定义 TFMobileBertMainLayer 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
class TFMobileBertModel(metaclass=DummyObject):
# 定义 TFMobileBertModel 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
class TFMobileBertPreTrainedModel(metaclass=DummyObject):
# 定义 TFMobileBertPreTrainedModel 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义 TF_MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST 常量,初始化为 None
class TFMobileViTForImageClassification(metaclass=DummyObject):
# 定义 TFMobileViTForImageClassification 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保当前实例支持 "tf" 后端
class TFMobileViTForSemanticSegmentation(metaclass=DummyObject):
# 定义 TFMobileViTForSemanticSegmentation 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保当前实例支持 "tf" 后端
class TFMobileViTModel(metaclass=DummyObject):
# 定义 TFMobileViTModel 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
class TFMobileViTPreTrainedModel(metaclass=DummyObject):
# 定义 TFMobileViTPreTrainedModel 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
TF_MPNET_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义 TF_MPNET_PRETRAINED_MODEL_ARCHIVE_LIST 常量,初始化为 None
class TFMPNetForMaskedLM(metaclass=DummyObject):
# 定义 TFMPNetForMaskedLM 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
class TFMPNetForMultipleChoice(metaclass=DummyObject):
# 定义 TFMPNetForMultipleChoice 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
class TFMPNetForQuestionAnswering(metaclass=DummyObject):
# 定义 TFMPNetForQuestionAnswering 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
class TFMPNetForSequenceClassification(metaclass=DummyObject):
# 定义 TFMPNetForSequenceClassification 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
class TFMPNetForTokenClassification(metaclass=DummyObject):
# 定义 TFMPNetForTokenClassification 类,使用 DummyObject 作为元类
_backends = ["tf"]
# 类属性 _backends,指定支持的后端为 "tf"
# 定义一个初始化方法,用于实例化对象时初始化其状态
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFMPNetMainLayer(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFMPNetModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFMPNetPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFMT5EncoderModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFMT5ForConditionalGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFMT5Model(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFOpenAIGPTDoubleHeadsModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFOpenAIGPTForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFOpenAIGPTLMHeadModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFOpenAIGPTMainLayer(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFOpenAIGPTModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFOpenAIGPTPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFOPTForCausalLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFOPTModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFOPTPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFPegasusForConditionalGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFPegasusModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFPegasusPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 要求使用 TensorFlow 后端
requires_backends(self, ["tf"])
class TFRagModel(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法,用于对象的初始化操作
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFRagPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRagSequenceForGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRagTokenForGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 设置 TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST 为 None,未定义预训练模型的存档列表
class TFRegNetForImageClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRegNetModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRegNetPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
TF_REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 设置 TF_REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST 为 None,未定义预训练模型的存档列表
class TFRemBertForCausalLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRemBertForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRemBertForMultipleChoice(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRemBertForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRemBertForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRemBertForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRemBertLayer(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRemBertModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFRemBertPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 设置 TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST 为 None,未定义预训练模型的存档列表
class TFResNetForImageClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFResNetModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 初始化方法,设置类属性 _backends 为 ["tf"],表示该类依赖于 TensorFlow 后端
class TFResNetPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
# 初始化方法未定义,未设置 requires_backends,但仍然表明该类依赖于 TensorFlow 后端
# 定义一个初始化方法,用于类的实例化过程,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,传入当前对象实例和一个包含字符串 "tf" 的列表,确保 "tf" 后端被加载
requires_backends(self, ["tf"])
# 定义一个全局变量,用于存储 TF-Roberta 预训练模型的存档列表,初始为 None
TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义一个虚拟类 TFRobertaForCausalLM,用于表示 TF-Roberta 模型的因果语言建模任务
class TFRobertaForCausalLM(metaclass=DummyObject):
# 指定后端为 TensorFlow
_backends = ["tf"]
# 初始化方法,要求确保后端为 TensorFlow
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaForMaskedLM,表示 TF-Roberta 模型的遮蔽语言建模任务
class TFRobertaForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaForMultipleChoice,表示 TF-Roberta 模型的多项选择任务
class TFRobertaForMultipleChoice(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaForQuestionAnswering,表示 TF-Roberta 模型的问答任务
class TFRobertaForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaForSequenceClassification,表示 TF-Roberta 模型的序列分类任务
class TFRobertaForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaForTokenClassification,表示 TF-Roberta 模型的标记分类任务
class TFRobertaForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaMainLayer,表示 TF-Roberta 模型的主层
class TFRobertaMainLayer(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaModel,表示 TF-Roberta 模型
class TFRobertaModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaPreTrainedModel,表示 TF-Roberta 预训练模型
class TFRobertaPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义一个全局变量,用于存储 TF-Roberta 预层归一化模型的存档列表,初始为 None
TF_ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义类 TFRobertaPreLayerNormForCausalLM,表示 TF-Roberta 预层归一化模型的因果语言建模任务
class TFRobertaPreLayerNormForCausalLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaPreLayerNormForMaskedLM,表示 TF-Roberta 预层归一化模型的遮蔽语言建模任务
class TFRobertaPreLayerNormForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaPreLayerNormForMultipleChoice,表示 TF-Roberta 预层归一化模型的多项选择任务
class TFRobertaPreLayerNormForMultipleChoice(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaPreLayerNormForQuestionAnswering,表示 TF-Roberta 预层归一化模型的问答任务
class TFRobertaPreLayerNormForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaPreLayerNormForSequenceClassification,表示 TF-Roberta 预层归一化模型的序列分类任务
class TFRobertaPreLayerNormForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaPreLayerNormForTokenClassification,表示 TF-Roberta 预层归一化模型的标记分类任务
class TFRobertaPreLayerNormForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaPreLayerNormMainLayer,表示 TF-Roberta 预层归一化模型的主层
class TFRobertaPreLayerNormMainLayer(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
# 定义类 TFRobertaPreLayerNormModel,表示 TF-Roberta 预层归一化模型
class TFRobertaPreLayerNormModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tf"])
class TFRobertaPreLayerNormPreTrainedModel(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF Roberta 预处理层规范预训练模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
TF_ROFORMER_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义 TF RoFormer 预训练模型存档列表为空
class TFRoFormerForCausalLM(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF RoFormer 因果语言模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFRoFormerForMaskedLM(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF RoFormer 掩码语言模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFRoFormerForMultipleChoice(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF RoFormer 多选模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFRoFormerForQuestionAnswering(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF RoFormer 问答模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFRoFormerForSequenceClassification(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF RoFormer 序列分类模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFRoFormerForTokenClassification(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF RoFormer 标记分类模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFRoFormerLayer(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF RoFormer 层
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFRoFormerModel(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF RoFormer 模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFRoFormerPreTrainedModel(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF RoFormer 预训练模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义 TF SAM 预训练模型存档列表为空
class TFSamModel(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF SAM 模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFSamPreTrainedModel(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF SAM 预训练模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
TF_SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST = None
# 定义 TF SegFormer 预训练模型存档列表为空
class TFSegformerDecodeHead(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF SegFormer 解码头
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFSegformerForImageClassification(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF SegFormer 图像分类模型
_backends = ["tf"]
# 类属性,指定该类的后端为 TensorFlow
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意数量的位置参数和关键字参数
requires_backends(self, ["tf"])
# 调用 requires_backends 函数,确保该类实例在 TensorFlow 后端下运行
class TFSegformerForSemanticSegmentation(metaclass=DummyObject):
# 定义一个带有 DummyObject 元类的类,用于 TF
class TFSpeech2TextForConditionalGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFSpeech2TextModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFSpeech2TextPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFSwinForImageClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFSwinForMaskedImageModeling(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFSwinModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFSwinPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFT5EncoderModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFT5ForConditionalGeneration(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFT5Model(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFT5PreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFTapasForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFTapasForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFTapasForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFTapasModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFTapasPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFVisionEncoderDecoderModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 确保此类需要依赖 TensorFlow 后端
requires_backends(self, ["tf"])
class TFVisionTextDualEncoderModel(metaclass=DummyObject):
_backends = ["tf"]
# 定义一个初始化方法,用于实例化对象时进行初始化操作
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,检查当前对象是否需要依赖 "tf" 后端
requires_backends(self, ["tf"])
class TFViTForImageClassification(metaclass=DummyObject):
# 定义 TFViT 图像分类模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFViTModel(metaclass=DummyObject):
# 定义 TFViT 模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFViTPreTrainedModel(metaclass=DummyObject):
# 定义 TFViT 预训练模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFViTMAEForPreTraining(metaclass=DummyObject):
# 定义 TFViT 预训练模型用于预训练,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFViTMAEModel(metaclass=DummyObject):
# 定义 TFViT 模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFViTMAEPreTrainedModel(metaclass=DummyObject):
# 定义 TFViT 预训练模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFWav2Vec2ForCTC(metaclass=DummyObject):
# 定义 TFWav2Vec2 CTC 模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFWav2Vec2ForSequenceClassification(metaclass=DummyObject):
# 定义 TFWav2Vec2 序列分类模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFWav2Vec2Model(metaclass=DummyObject):
# 定义 TFWav2Vec2 模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFWav2Vec2PreTrainedModel(metaclass=DummyObject):
# 定义 TFWav2Vec2 预训练模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFWhisperForConditionalGeneration(metaclass=DummyObject):
# 定义 TFWhisper 条件生成模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFWhisperModel(metaclass=DummyObject):
# 定义 TFWhisper 模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFWhisperPreTrainedModel(metaclass=DummyObject):
# 定义 TFWhisper 预训练模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFXGLMForCausalLM(metaclass=DummyObject):
# 定义 TFXGLM 因果语言模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFXGLMModel(metaclass=DummyObject):
# 定义 TFXGLM 模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFXGLMPreTrainedModel(metaclass=DummyObject):
# 定义 TFXGLM 预训练模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFXLMForMultipleChoice(metaclass=DummyObject):
# 定义 TFXLM 多项选择模型,使用 DummyObject 元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化函数,确保后端为 TensorFlow
requires_backends(self, ["tf"])
class TFXLMForQuestionAnsweringSimple(metaclass=DummyObject):
# 定义 TFXLM 简单问答模型,使用 DummyObject 元类
_backends = ["tf"]
# 定义类的初始化方法,用于创建类的实例时执行一些初始化操作
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前环境中存在 "tf" 这个后端
requires_backends(self, ["tf"])
class TFXLMForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于序列分类任务的 TF-XLM 模型
requires_backends(self, ["tf"])
class TFXLMForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于标记分类任务的 TF-XLM 模型
requires_backends(self, ["tf"])
class TFXLMMainLayer(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,TF-XLM 主层
requires_backends(self, ["tf"])
class TFXLMModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,TF-XLM 模型
requires_backends(self, ["tf"])
class TFXLMPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,TF-XLM 预训练模型
requires_backends(self, ["tf"])
class TFXLMWithLMHeadModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,带有语言模型头部的 TF-XLM 模型
requires_backends(self, ["tf"])
TF_XLM_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFXLMRobertaForCausalLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于因果语言建模的 TF-XLM RoBERTa 模型
requires_backends(self, ["tf"])
class TFXLMRobertaForMaskedLM(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于遮蔽语言建模的 TF-XLM RoBERTa 模型
requires_backends(self, ["tf"])
class TFXLMRobertaForMultipleChoice(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于多项选择任务的 TF-XLM RoBERTa 模型
requires_backends(self, ["tf"])
class TFXLMRobertaForQuestionAnswering(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于问答任务的 TF-XLM RoBERTa 模型
requires_backends(self, ["tf"])
class TFXLMRobertaForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于序列分类任务的 TF-XLM RoBERTa 模型
requires_backends(self, ["tf"])
class TFXLMRobertaForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于标记分类任务的 TF-XLM RoBERTa 模型
requires_backends(self, ["tf"])
class TFXLMRobertaModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,TF-XLM RoBERTa 模型
requires_backends(self, ["tf"])
class TFXLMRobertaPreTrainedModel(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,TF-XLM RoBERTa 预训练模型
requires_backends(self, ["tf"])
TF_XLNET_PRETRAINED_MODEL_ARCHIVE_LIST = None
class TFXLNetForMultipleChoice(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于多项选择任务的 TF-XLNet 模型
requires_backends(self, ["tf"])
class TFXLNetForQuestionAnsweringSimple(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于简单问答任务的 TF-XLNet 模型
requires_backends(self, ["tf"])
class TFXLNetForSequenceClassification(metaclass=DummyObject):
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 使用 DummyObject 元类创建的类,用于序列分类任务的 TF-XLNet 模型
requires_backends(self, ["tf"])
class TFXLNetForTokenClassification(metaclass=DummyObject):
_backends = ["tf"]
# 定义初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前类实例依赖于 "tf" 后端
requires_backends(self, ["tf"])
class TFXLNetLMHeadModel(metaclass=DummyObject):
# 定义一个类 TFXLNetLMHeadModel,使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置参数和关键字参数
requires_backends(self, ["tf"]) # 调用 requires_backends 函数,确保当前对象需要的后端是 "tf"
class TFXLNetMainLayer(metaclass=DummyObject):
# 定义一个类 TFXLNetMainLayer,使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置参数和关键字参数
requires_backends(self, ["tf"]) # 调用 requires_backends 函数,确保当前对象需要的后端是 "tf"
class TFXLNetModel(metaclass=DummyObject):
# 定义一个类 TFXLNetModel,使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置参数和关键字参数
requires_backends(self, ["tf"]) # 调用 requires_backends 函数,确保当前对象需要的后端是 "tf"
class TFXLNetPreTrainedModel(metaclass=DummyObject):
# 定义一个类 TFXLNetPreTrainedModel,使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置参数和关键字参数
requires_backends(self, ["tf"]) # 调用 requires_backends 函数,确保当前对象需要的后端是 "tf"
class AdamWeightDecay(metaclass=DummyObject):
# 定义一个类 AdamWeightDecay,使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置参数和关键字参数
requires_backends(self, ["tf"]) # 调用 requires_backends 函数,确保当前对象需要的后端是 "tf"
class GradientAccumulator(metaclass=DummyObject):
# 定义一个类 GradientAccumulator,使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置参数和关键字参数
requires_backends(self, ["tf"]) # 调用 requires_backends 函数,确保当前对象需要的后端是 "tf"
class WarmUp(metaclass=DummyObject):
# 定义一个类 WarmUp,使用 DummyObject 作为元类
_backends = ["tf"]
def __init__(self, *args, **kwargs):
# 初始化方法,接受任意位置参数和关键字参数
requires_backends(self, ["tf"]) # 调用 requires_backends 函数,确保当前对象需要的后端是 "tf"
def create_optimizer(*args, **kwargs):
# 定义函数 create_optimizer,接受任意位置参数和关键字参数
requires_backends(create_optimizer, ["tf"]) # 调用 requires_backends 函数,确保当前函数需要的后端是 "tf"
.\utils\dummy_tokenizers_objects.py
# 此文件由命令 `make fix-copies` 自动生成,不要编辑。
# 从上级目录的 utils 模块中导入 DummyObject 类和 requires_backends 函数
from ..utils import DummyObject, requires_backends
# 定义 AlbertTokenizerFast 类,使用 DummyObject 元类
class AlbertTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 BartTokenizerFast 类,使用 DummyObject 元类
class BartTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 BarthezTokenizerFast 类,使用 DummyObject 元类
class BarthezTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 BertTokenizerFast 类,使用 DummyObject 元类
class BertTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 BigBirdTokenizerFast 类,使用 DummyObject 元类
class BigBirdTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 BlenderbotTokenizerFast 类,使用 DummyObject 元类
class BlenderbotTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 BlenderbotSmallTokenizerFast 类,使用 DummyObject 元类
class BlenderbotSmallTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 BloomTokenizerFast 类,使用 DummyObject 元类
class BloomTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 CamembertTokenizerFast 类,使用 DummyObject 元类
class CamembertTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 CLIPTokenizerFast 类,使用 DummyObject 元类
class CLIPTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 CodeLlamaTokenizerFast 类,使用 DummyObject 元类
class CodeLlamaTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 CodeGenTokenizerFast 类,使用 DummyObject 元类
class CodeGenTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 CohereTokenizerFast 类,使用 DummyObject 元类
class CohereTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 ConvBertTokenizerFast 类,使用 DummyObject 元类
class ConvBertTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 CpmTokenizerFast 类,使用 DummyObject 元类
class CpmTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖于 "tokenizers" 后端
requires_backends(self, ["tokenizers"])
# 定义 DebertaTokenizerFast 类,使用 DummyObject 元类
class DebertaTokenizerFast(metaclass=DummyObject):
# 定义 _backends 类变量,指定为 ["tokenizers"]
_backends = ["tokenizers"]
# 初始化方法,接受任意参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保对象依赖
# 初始化方法,用于对象的初始化
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖的 "tokenizers" 后端可用
requires_backends(self, ["tokenizers"])
class RetriBertTokenizerFast(metaclass=DummyObject):
# 定义一个名为 RetriBertTokenizerFast 的类,使用 DummyObject 作为元类
_backends = ["tokenizers"]
# 类属性 _backends,存储字符串列表 ["tokenizers"]
def __init__(self, *args, **kwargs):
# 构造函数,接受任意位置参数 *args 和任意关键字参数 **kwargs
requires_backends(self, ["tokenizers"])
# 调用 requires_backends 函数,确保 self 实例依赖于 "tokenizers" 后端
class DistilBertTokenizerFast(metaclass=DummyObject):
# 定义一个名为 DistilBertTokenizerFast 的类,使用 DummyObject 作为元类
_backends = ["tokenizers"]
# 类属性 _backends,存储字符串列表 ["tokenizers"]
def __init__(self, *args, **kwargs):
# 构造函数,接受任意位置参数 *args 和任意关键字参数 **kwargs
requires_backends(self, ["tokenizers"])
# 调用 requires_backends 函数,确保 self 实例依赖于 "tokenizers" 后端
# 后续类的结构与上述类似,均包含一个名为 _backends 的类属性和一个构造函数
# 每个构造函数都调用 requires_backends 函数确保依赖于 "tokenizers" 后端
class DPRContextEncoderTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class DPRQuestionEncoderTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class DPRReaderTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class ElectraTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class FNetTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class FunnelTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class GemmaTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class GPT2TokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class GPTNeoXTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class GPTNeoXJapaneseTokenizer(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class HerbertTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class LayoutLMTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class LayoutLMv2TokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class LayoutLMv3TokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class LayoutXLMTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class LEDTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class LlamaTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class LongformerTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class LxmertTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class MarkupLMTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class MBartTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class MBart50TokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class MobileBertTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class MPNetTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class MT5TokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class MvpTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class NllbTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class NougatTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class OpenAIGPTTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class PegasusTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class Qwen2TokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class RealmTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"]) # 调用函数 requires_backends,确保实例依赖 "tokenizers" 后端
class ReformerTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"] # 定义类属性 _backends,值为包含字符串 "tokenizers" 的列表
# 定义一个类变量 `_backends`,其值是包含字符串 "tokenizers" 的列表,可能用于指示类依赖的后端组件。
_backends = ["tokenizers"]
# 类的初始化方法,接受任意数量的位置参数和关键字参数。
def __init__(self, *args, **kwargs):
# 调用 `requires_backends` 函数,验证当前类实例是否具有所需的后端组件 "tokenizers"。
requires_backends(self, ["tokenizers"])
# 定义一个自定义元类 DummyObject,用于创建带有特定后端依赖的快速标记器类
class RemBertTokenizerFast(metaclass=DummyObject):
# 定义类属性 _backends,表示此标记器类依赖于名为 "tokenizers" 的后端
_backends = ["tokenizers"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用函数 requires_backends,确保实例具有必需的后端依赖
requires_backends(self, ["tokenizers"])
class RobertaTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class RoFormerTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class SeamlessM4TTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class SplinterTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class SqueezeBertTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class T5TokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class UdopTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class WhisperTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class XGLMTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class XLMRobertaTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class XLNetTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
class PreTrainedTokenizerFast(metaclass=DummyObject):
_backends = ["tokenizers"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["tokenizers"])
.\utils\dummy_torchaudio_objects.py
# 这个文件是由命令 `make fix-copies` 自动生成的,不要编辑。
# 导入必要的模块和函数:DummyObject 和 requires_backends
from ..utils import DummyObject, requires_backends
# 定义一个元类为 DummyObject 的类 MusicgenMelodyFeatureExtractor
class MusicgenMelodyFeatureExtractor(metaclass=DummyObject):
# 类属性 _backends,指定依赖的后端库为 "torchaudio"
_backends = ["torchaudio"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保类实例依赖的后端库符合要求
requires_backends(self, ["torchaudio"])
# 定义一个元类为 DummyObject 的类 MusicgenMelodyProcessor
class MusicgenMelodyProcessor(metaclass=DummyObject):
# 类属性 _backends,指定依赖的后端库为 "torchaudio"
_backends = ["torchaudio"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保类实例依赖的后端库符合要求
requires_backends(self, ["torchaudio"])
.\utils\dummy_vision_objects.py
# This file is autogenerated by the command `make fix-copies`, do not edit.
# 从上级目录的utils模块导入DummyObject和requires_backends函数
from ..utils import DummyObject, requires_backends
# 定义一个图像处理的Mixin类,使用DummyObject作为元类
class ImageProcessingMixin(metaclass=DummyObject):
# 定义_backends属性,指定为"vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用requires_backends函数,确保self对象有"vision"后端
requires_backends(self, ["vision"])
# 定义一个图像特征提取的Mixin类,使用DummyObject作为元类
class ImageFeatureExtractionMixin(metaclass=DummyObject):
# 定义_backends属性,指定为"vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用requires_backends函数,确保self对象有"vision"后端
requires_backends(self, ["vision"])
# 后续类似地定义了多个图像处理器和特征提取器的类,每个类都有相同的结构和目的。
# 以下省略类的注释,因为它们的结构和作用完全相同,只是名称不同。
class BeitFeatureExtractor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class BeitImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class BitImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class BlipImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class BridgeTowerImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class ChineseCLIPFeatureExtractor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class ChineseCLIPImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class CLIPFeatureExtractor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class CLIPImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class ConditionalDetrFeatureExtractor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class ConditionalDetrImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class ConvNextFeatureExtractor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class ConvNextImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class DeformableDetrFeatureExtractor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
requires_backends(self, ["vision"])
class DeformableDetrImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
# 初始化方法,用于实例化对象时进行初始化操作
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,检查当前对象是否满足需要的后端条件
requires_backends(self, ["vision"])
# 定义一个名为 DeiTFeatureExtractor 的类,使用 DummyObject 元类
class DeiTFeatureExtractor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 DeiTImageProcessor 的类,使用 DummyObject 元类
class DeiTImageProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 DetaImageProcessor 的类,使用 DummyObject 元类
class DetaImageProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 DetrFeatureExtractor 的类,使用 DummyObject 元类
class DetrFeatureExtractor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 DetrImageProcessor 的类,使用 DummyObject 元类
class DetrImageProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 DonutFeatureExtractor 的类,使用 DummyObject 元类
class DonutFeatureExtractor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 DonutImageProcessor 的类,使用 DummyObject 元类
class DonutImageProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 DPTFeatureExtractor 的类,使用 DummyObject 元类
class DPTFeatureExtractor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 DPTImageProcessor 的类,使用 DummyObject 元类
class DPTImageProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 EfficientFormerImageProcessor 的类,使用 DummyObject 元类
class EfficientFormerImageProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 EfficientNetImageProcessor 的类,使用 DummyObject 元类
class EfficientNetImageProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 FlavaFeatureExtractor 的类,使用 DummyObject 元类
class FlavaFeatureExtractor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 FlavaImageProcessor 的类,使用 DummyObject 元类
class FlavaImageProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 FlavaProcessor 的类,使用 DummyObject 元类
class FlavaProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 FuyuImageProcessor 的类,使用 DummyObject 元类
class FuyuImageProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例依赖于 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 FuyuProcessor 的类,使用 DummyObject 元类
class FuyuProcessor(metaclass=DummyObject):
# 类属性 _backends 指定为包含字符串 "vision" 的列表
_backends = ["vision"]
# 初始化方法,接受任意位置和关键字参数
# 定义一个名为 IdeficsImageProcessor 的类,使用 DummyObject 作为元类
class IdeficsImageProcessor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 ImageGPTFeatureExtractor 的类,使用 DummyObject 作为元类
class ImageGPTFeatureExtractor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 ImageGPTImageProcessor 的类,使用 DummyObject 作为元类
class ImageGPTImageProcessor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 LayoutLMv2FeatureExtractor 的类,使用 DummyObject 作为元类
class LayoutLMv2FeatureExtractor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 LayoutLMv2ImageProcessor 的类,使用 DummyObject 作为元类
class LayoutLMv2ImageProcessor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 LayoutLMv3FeatureExtractor 的类,使用 DummyObject 作为元类
class LayoutLMv3FeatureExtractor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 LayoutLMv3ImageProcessor 的类,使用 DummyObject 作为元类
class LayoutLMv3ImageProcessor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 LevitFeatureExtractor 的类,使用 DummyObject 作为元类
class LevitFeatureExtractor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 LevitImageProcessor 的类,使用 DummyObject 作为元类
class LevitImageProcessor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 LlavaNextImageProcessor 的类,使用 DummyObject 作为元类
class LlavaNextImageProcessor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 Mask2FormerImageProcessor 的类,使用 DummyObject 作为元类
class Mask2FormerImageProcessor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 MaskFormerFeatureExtractor 的类,使用 DummyObject 作为元类
class MaskFormerFeatureExtractor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 MaskFormerImageProcessor 的类,使用 DummyObject 作为元类
class MaskFormerImageProcessor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 MobileNetV1FeatureExtractor 的类,使用 DummyObject 作为元类
class MobileNetV1FeatureExtractor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 MobileNetV1ImageProcessor 的类,使用 DummyObject 作为元类
class MobileNetV1ImageProcessor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义一个名为 MobileNetV2FeatureExtractor 的类,使用 DummyObject 作为元类
class MobileNetV2FeatureExtractor(metaclass=DummyObject):
# 类变量 _backends,包含字符串 "vision"
_backends = ["vision"]
# 初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前实例对象有 "vision" 后端
requires_backends(self, ["vision"])
# 定义
# 定义一个初始化方法,接受任意位置参数和关键字参数
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,验证当前对象是否具备 "vision" 后端所需的依赖
requires_backends(self, ["vision"])
class MobileViTImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class NougatImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class OneFormerImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class Owlv2ImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class OwlViTFeatureExtractor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class OwlViTImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class PerceiverFeatureExtractor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class PerceiverImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class Pix2StructImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class PoolFormerFeatureExtractor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class PoolFormerImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class PvtImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class SamImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class SegformerFeatureExtractor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class SegformerImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class SegGptImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class SiglipImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 要求当前类实例化时必须依赖 "vision" 后端
requires_backends(self, ["vision"])
class SuperPointImageProcessor(metaclass=DummyObject):
_backends = ["vision"]
# 初始化方法,用于实例化对象时进行初始化操作
def __init__(self, *args, **kwargs):
# 调用 requires_backends 函数,确保当前对象依赖的后端包括 "vision"
requires_backends(self, ["vision"])
class Swin2SRImageProcessor(metaclass=DummyObject):
# Swin2SR 图像处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class TvltImageProcessor(metaclass=DummyObject):
# Tvlt 图像处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class TvpImageProcessor(metaclass=DummyObject):
# Tvp 图像处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class VideoMAEFeatureExtractor(metaclass=DummyObject):
# 视频 MAE 特征提取器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class VideoMAEImageProcessor(metaclass=DummyObject):
# 视频 MAE 图像处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class ViltFeatureExtractor(metaclass=DummyObject):
# Vilt 特征提取器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class ViltImageProcessor(metaclass=DummyObject):
# Vilt 图像处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class ViltProcessor(metaclass=DummyObject):
# Vilt 处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class ViTFeatureExtractor(metaclass=DummyObject):
# ViT 特征提取器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class ViTImageProcessor(metaclass=DummyObject):
# ViT 图像处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class ViTHybridImageProcessor(metaclass=DummyObject):
# ViT 混合图像处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class VitMatteImageProcessor(metaclass=DummyObject):
# VitMatte 图像处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class VivitImageProcessor(metaclass=DummyObject):
# Vivit 图像处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class YolosFeatureExtractor(metaclass=DummyObject):
# Yolos 特征提取器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])
class YolosImageProcessor(metaclass=DummyObject):
# Yolos 图像处理器类,使用 DummyObject 作为元类
_backends = ["vision"]
def __init__(self, *args, **kwargs):
# 初始化方法,确保需要 "vision" 后端
requires_backends(self, ["vision"])