Spaces:
Sleeping
Sleeping
# coding=utf-8 | |
# Copyright 2018 The HuggingFace Inc. team. | |
# | |
# Licensed under the Apache License, Version 2.0 (the "License"); | |
# you may not use this file except in compliance with the License. | |
# You may obtain a copy of the License at | |
# | |
# http://www.apache.org/licenses/LICENSE-2.0 | |
# | |
# Unless required by applicable law or agreed to in writing, software | |
# distributed under the License is distributed on an "AS IS" BASIS, | |
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
# See the License for the specific language governing permissions and | |
# limitations under the License. | |
""" Auto Config class.""" | |
import importlib | |
import os | |
import re | |
import warnings | |
from collections import OrderedDict | |
from typing import List, Union | |
from ...configuration_utils import PretrainedConfig | |
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code | |
from ...utils import CONFIG_NAME, logging | |
logger = logging.get_logger(__name__) | |
CONFIG_MAPPING_NAMES = OrderedDict( | |
[ | |
# Add configs here | |
("albert", "AlbertConfig"), | |
("align", "AlignConfig"), | |
("altclip", "AltCLIPConfig"), | |
("audio-spectrogram-transformer", "ASTConfig"), | |
("autoformer", "AutoformerConfig"), | |
("bark", "BarkConfig"), | |
("bart", "BartConfig"), | |
("beit", "BeitConfig"), | |
("bert", "BertConfig"), | |
("bert-generation", "BertGenerationConfig"), | |
("big_bird", "BigBirdConfig"), | |
("bigbird_pegasus", "BigBirdPegasusConfig"), | |
("biogpt", "BioGptConfig"), | |
("bit", "BitConfig"), | |
("blenderbot", "BlenderbotConfig"), | |
("blenderbot-small", "BlenderbotSmallConfig"), | |
("blip", "BlipConfig"), | |
("blip-2", "Blip2Config"), | |
("bloom", "BloomConfig"), | |
("bridgetower", "BridgeTowerConfig"), | |
("bros", "BrosConfig"), | |
("camembert", "CamembertConfig"), | |
("canine", "CanineConfig"), | |
("chinese_clip", "ChineseCLIPConfig"), | |
("clap", "ClapConfig"), | |
("clip", "CLIPConfig"), | |
("clipseg", "CLIPSegConfig"), | |
("code_llama", "LlamaConfig"), | |
("codegen", "CodeGenConfig"), | |
("conditional_detr", "ConditionalDetrConfig"), | |
("convbert", "ConvBertConfig"), | |
("convnext", "ConvNextConfig"), | |
("convnextv2", "ConvNextV2Config"), | |
("cpmant", "CpmAntConfig"), | |
("ctrl", "CTRLConfig"), | |
("cvt", "CvtConfig"), | |
("data2vec-audio", "Data2VecAudioConfig"), | |
("data2vec-text", "Data2VecTextConfig"), | |
("data2vec-vision", "Data2VecVisionConfig"), | |
("deberta", "DebertaConfig"), | |
("deberta-v2", "DebertaV2Config"), | |
("decision_transformer", "DecisionTransformerConfig"), | |
("deformable_detr", "DeformableDetrConfig"), | |
("deit", "DeiTConfig"), | |
("deta", "DetaConfig"), | |
("detr", "DetrConfig"), | |
("dinat", "DinatConfig"), | |
("dinov2", "Dinov2Config"), | |
("distilbert", "DistilBertConfig"), | |
("donut-swin", "DonutSwinConfig"), | |
("dpr", "DPRConfig"), | |
("dpt", "DPTConfig"), | |
("efficientformer", "EfficientFormerConfig"), | |
("efficientnet", "EfficientNetConfig"), | |
("electra", "ElectraConfig"), | |
("encodec", "EncodecConfig"), | |
("encoder-decoder", "EncoderDecoderConfig"), | |
("ernie", "ErnieConfig"), | |
("ernie_m", "ErnieMConfig"), | |
("esm", "EsmConfig"), | |
("falcon", "FalconConfig"), | |
("flaubert", "FlaubertConfig"), | |
("flava", "FlavaConfig"), | |
("fnet", "FNetConfig"), | |
("focalnet", "FocalNetConfig"), | |
("fsmt", "FSMTConfig"), | |
("funnel", "FunnelConfig"), | |
("git", "GitConfig"), | |
("glpn", "GLPNConfig"), | |
("gpt-sw3", "GPT2Config"), | |
("gpt2", "GPT2Config"), | |
("gpt_bigcode", "GPTBigCodeConfig"), | |
("gpt_neo", "GPTNeoConfig"), | |
("gpt_neox", "GPTNeoXConfig"), | |
("gpt_neox_japanese", "GPTNeoXJapaneseConfig"), | |
("gptj", "GPTJConfig"), | |
("gptsan-japanese", "GPTSanJapaneseConfig"), | |
("graphormer", "GraphormerConfig"), | |
("groupvit", "GroupViTConfig"), | |
("hubert", "HubertConfig"), | |
("ibert", "IBertConfig"), | |
("idefics", "IdeficsConfig"), | |
("imagegpt", "ImageGPTConfig"), | |
("informer", "InformerConfig"), | |
("instructblip", "InstructBlipConfig"), | |
("jukebox", "JukeboxConfig"), | |
("layoutlm", "LayoutLMConfig"), | |
("layoutlmv2", "LayoutLMv2Config"), | |
("layoutlmv3", "LayoutLMv3Config"), | |
("led", "LEDConfig"), | |
("levit", "LevitConfig"), | |
("lilt", "LiltConfig"), | |
("llama", "LlamaConfig"), | |
("longformer", "LongformerConfig"), | |
("longt5", "LongT5Config"), | |
("luke", "LukeConfig"), | |
("lxmert", "LxmertConfig"), | |
("m2m_100", "M2M100Config"), | |
("marian", "MarianConfig"), | |
("markuplm", "MarkupLMConfig"), | |
("mask2former", "Mask2FormerConfig"), | |
("maskformer", "MaskFormerConfig"), | |
("maskformer-swin", "MaskFormerSwinConfig"), | |
("mbart", "MBartConfig"), | |
("mctct", "MCTCTConfig"), | |
("mega", "MegaConfig"), | |
("megatron-bert", "MegatronBertConfig"), | |
("mgp-str", "MgpstrConfig"), | |
("mistral", "MistralConfig"), | |
("mobilebert", "MobileBertConfig"), | |
("mobilenet_v1", "MobileNetV1Config"), | |
("mobilenet_v2", "MobileNetV2Config"), | |
("mobilevit", "MobileViTConfig"), | |
("mobilevitv2", "MobileViTV2Config"), | |
("mpnet", "MPNetConfig"), | |
("mpt", "MptConfig"), | |
("mra", "MraConfig"), | |
("mt5", "MT5Config"), | |
("musicgen", "MusicgenConfig"), | |
("mvp", "MvpConfig"), | |
("nat", "NatConfig"), | |
("nezha", "NezhaConfig"), | |
("nllb-moe", "NllbMoeConfig"), | |
("nougat", "VisionEncoderDecoderConfig"), | |
("nystromformer", "NystromformerConfig"), | |
("oneformer", "OneFormerConfig"), | |
("open-llama", "OpenLlamaConfig"), | |
("openai-gpt", "OpenAIGPTConfig"), | |
("opt", "OPTConfig"), | |
("owlvit", "OwlViTConfig"), | |
("pegasus", "PegasusConfig"), | |
("pegasus_x", "PegasusXConfig"), | |
("perceiver", "PerceiverConfig"), | |
("persimmon", "PersimmonConfig"), | |
("pix2struct", "Pix2StructConfig"), | |
("plbart", "PLBartConfig"), | |
("poolformer", "PoolFormerConfig"), | |
("pop2piano", "Pop2PianoConfig"), | |
("prophetnet", "ProphetNetConfig"), | |
("pvt", "PvtConfig"), | |
("qdqbert", "QDQBertConfig"), | |
("rag", "RagConfig"), | |
("realm", "RealmConfig"), | |
("reformer", "ReformerConfig"), | |
("regnet", "RegNetConfig"), | |
("rembert", "RemBertConfig"), | |
("resnet", "ResNetConfig"), | |
("retribert", "RetriBertConfig"), | |
("roberta", "RobertaConfig"), | |
("roberta-prelayernorm", "RobertaPreLayerNormConfig"), | |
("roc_bert", "RoCBertConfig"), | |
("roformer", "RoFormerConfig"), | |
("rwkv", "RwkvConfig"), | |
("sam", "SamConfig"), | |
("segformer", "SegformerConfig"), | |
("sew", "SEWConfig"), | |
("sew-d", "SEWDConfig"), | |
("speech-encoder-decoder", "SpeechEncoderDecoderConfig"), | |
("speech_to_text", "Speech2TextConfig"), | |
("speech_to_text_2", "Speech2Text2Config"), | |
("speecht5", "SpeechT5Config"), | |
("splinter", "SplinterConfig"), | |
("squeezebert", "SqueezeBertConfig"), | |
("swiftformer", "SwiftFormerConfig"), | |
("swin", "SwinConfig"), | |
("swin2sr", "Swin2SRConfig"), | |
("swinv2", "Swinv2Config"), | |
("switch_transformers", "SwitchTransformersConfig"), | |
("t5", "T5Config"), | |
("table-transformer", "TableTransformerConfig"), | |
("tapas", "TapasConfig"), | |
("time_series_transformer", "TimeSeriesTransformerConfig"), | |
("timesformer", "TimesformerConfig"), | |
("timm_backbone", "TimmBackboneConfig"), | |
("trajectory_transformer", "TrajectoryTransformerConfig"), | |
("transfo-xl", "TransfoXLConfig"), | |
("trocr", "TrOCRConfig"), | |
("tvlt", "TvltConfig"), | |
("umt5", "UMT5Config"), | |
("unispeech", "UniSpeechConfig"), | |
("unispeech-sat", "UniSpeechSatConfig"), | |
("upernet", "UperNetConfig"), | |
("van", "VanConfig"), | |
("videomae", "VideoMAEConfig"), | |
("vilt", "ViltConfig"), | |
("vision-encoder-decoder", "VisionEncoderDecoderConfig"), | |
("vision-text-dual-encoder", "VisionTextDualEncoderConfig"), | |
("visual_bert", "VisualBertConfig"), | |
("vit", "ViTConfig"), | |
("vit_hybrid", "ViTHybridConfig"), | |
("vit_mae", "ViTMAEConfig"), | |
("vit_msn", "ViTMSNConfig"), | |
("vitdet", "VitDetConfig"), | |
("vitmatte", "VitMatteConfig"), | |
("vits", "VitsConfig"), | |
("vivit", "VivitConfig"), | |
("wav2vec2", "Wav2Vec2Config"), | |
("wav2vec2-conformer", "Wav2Vec2ConformerConfig"), | |
("wavlm", "WavLMConfig"), | |
("whisper", "WhisperConfig"), | |
("xclip", "XCLIPConfig"), | |
("xglm", "XGLMConfig"), | |
("xlm", "XLMConfig"), | |
("xlm-prophetnet", "XLMProphetNetConfig"), | |
("xlm-roberta", "XLMRobertaConfig"), | |
("xlm-roberta-xl", "XLMRobertaXLConfig"), | |
("xlnet", "XLNetConfig"), | |
("xmod", "XmodConfig"), | |
("yolos", "YolosConfig"), | |
("yoso", "YosoConfig"), | |
] | |
) | |
CONFIG_ARCHIVE_MAP_MAPPING_NAMES = OrderedDict( | |
[ | |
# Add archive maps here) | |
("albert", "ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("align", "ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("altclip", "ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("audio-spectrogram-transformer", "AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("autoformer", "AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("bark", "BARK_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("bart", "BART_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("beit", "BEIT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("bert", "BERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("big_bird", "BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("bigbird_pegasus", "BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("biogpt", "BIOGPT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("bit", "BIT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("blenderbot", "BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("blenderbot-small", "BLENDERBOT_SMALL_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("blip", "BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("blip-2", "BLIP_2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("bloom", "BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("bridgetower", "BRIDGETOWER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("bros", "BROS_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("camembert", "CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("canine", "CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("chinese_clip", "CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("clap", "CLAP_PRETRAINED_MODEL_ARCHIVE_LIST"), | |
("clip", "CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("clipseg", "CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("codegen", "CODEGEN_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("conditional_detr", "CONDITIONAL_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("convbert", "CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("convnext", "CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("convnextv2", "CONVNEXTV2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("cpmant", "CPMANT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("ctrl", "CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("cvt", "CVT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("data2vec-audio", "DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("data2vec-text", "DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("data2vec-vision", "DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("deberta", "DEBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("deberta-v2", "DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("deformable_detr", "DEFORMABLE_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("deit", "DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("deta", "DETA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("detr", "DETR_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("dinat", "DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("dinov2", "DINOV2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("distilbert", "DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("donut-swin", "DONUT_SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("dpr", "DPR_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("dpt", "DPT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("efficientformer", "EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("efficientnet", "EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("electra", "ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("encodec", "ENCODEC_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("ernie", "ERNIE_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("ernie_m", "ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("esm", "ESM_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("falcon", "FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("flaubert", "FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("flava", "FLAVA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("fnet", "FNET_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("focalnet", "FOCALNET_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("fsmt", "FSMT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("funnel", "FUNNEL_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("git", "GIT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("glpn", "GLPN_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("gpt2", "GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("gpt_bigcode", "GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("gpt_neo", "GPT_NEO_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("gpt_neox", "GPT_NEOX_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("gpt_neox_japanese", "GPT_NEOX_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("gptj", "GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("gptsan-japanese", "GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("graphormer", "GRAPHORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("groupvit", "GROUPVIT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("hubert", "HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("ibert", "IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("idefics", "IDEFICS_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("imagegpt", "IMAGEGPT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("informer", "INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("instructblip", "INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("jukebox", "JUKEBOX_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("layoutlm", "LAYOUTLM_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("layoutlmv2", "LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("layoutlmv3", "LAYOUTLMV3_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("led", "LED_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("levit", "LEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("lilt", "LILT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("llama", "LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("longformer", "LONGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("longt5", "LONGT5_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("luke", "LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("lxmert", "LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("m2m_100", "M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("markuplm", "MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mask2former", "MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("maskformer", "MASKFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mbart", "MBART_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mctct", "MCTCT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mega", "MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("megatron-bert", "MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mgp-str", "MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mistral", "MISTRAL_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mobilenet_v1", "MOBILENET_V1_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mobilenet_v2", "MOBILENET_V2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mobilevit", "MOBILEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mobilevitv2", "MOBILEVITV2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mpnet", "MPNET_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mpt", "MPT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mra", "MRA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("musicgen", "MUSICGEN_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("mvp", "MVP_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("nat", "NAT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("nezha", "NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("nllb-moe", "NLLB_MOE_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("nystromformer", "NYSTROMFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("oneformer", "ONEFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("open-llama", "OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("openai-gpt", "OPENAI_GPT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("opt", "OPT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("owlvit", "OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("pegasus", "PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("pegasus_x", "PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("perceiver", "PERCEIVER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("persimmon", "PERSIMMON_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("pix2struct", "PIX2STRUCT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("plbart", "PLBART_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("poolformer", "POOLFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("pop2piano", "POP2PIANO_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("prophetnet", "PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("pvt", "PVT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("qdqbert", "QDQBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("realm", "REALM_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("regnet", "REGNET_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("rembert", "REMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("resnet", "RESNET_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("retribert", "RETRIBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("roberta", "ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("roberta-prelayernorm", "ROBERTA_PRELAYERNORM_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("roc_bert", "ROC_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("roformer", "ROFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("rwkv", "RWKV_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("sam", "SAM_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("segformer", "SEGFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("sew", "SEW_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("sew-d", "SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("speech_to_text", "SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("speech_to_text_2", "SPEECH_TO_TEXT_2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("speecht5", "SPEECHT5_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("splinter", "SPLINTER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("squeezebert", "SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("swiftformer", "SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("swin", "SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("swin2sr", "SWIN2SR_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("swinv2", "SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("switch_transformers", "SWITCH_TRANSFORMERS_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("t5", "T5_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("table-transformer", "TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("tapas", "TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("time_series_transformer", "TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("timesformer", "TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("transfo-xl", "TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("tvlt", "TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("unispeech", "UNISPEECH_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("unispeech-sat", "UNISPEECH_SAT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("van", "VAN_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("videomae", "VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("vilt", "VILT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("visual_bert", "VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("vit", "VIT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("vit_hybrid", "VIT_HYBRID_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("vit_mae", "VIT_MAE_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("vit_msn", "VIT_MSN_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("vitdet", "VITDET_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("vitmatte", "VITMATTE_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("vits", "VITS_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("vivit", "VIVIT_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("wav2vec2", "WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("wav2vec2-conformer", "WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("whisper", "WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("xclip", "XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("xglm", "XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("xlm", "XLM_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("xlm-prophetnet", "XLM_PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("xlm-roberta", "XLM_ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("xlnet", "XLNET_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("xmod", "XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("yolos", "YOLOS_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
("yoso", "YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP"), | |
] | |
) | |
MODEL_NAMES_MAPPING = OrderedDict( | |
[ | |
# Add full (and cased) model names here | |
("albert", "ALBERT"), | |
("align", "ALIGN"), | |
("altclip", "AltCLIP"), | |
("audio-spectrogram-transformer", "Audio Spectrogram Transformer"), | |
("autoformer", "Autoformer"), | |
("bark", "Bark"), | |
("bart", "BART"), | |
("barthez", "BARThez"), | |
("bartpho", "BARTpho"), | |
("beit", "BEiT"), | |
("bert", "BERT"), | |
("bert-generation", "Bert Generation"), | |
("bert-japanese", "BertJapanese"), | |
("bertweet", "BERTweet"), | |
("big_bird", "BigBird"), | |
("bigbird_pegasus", "BigBird-Pegasus"), | |
("biogpt", "BioGpt"), | |
("bit", "BiT"), | |
("blenderbot", "Blenderbot"), | |
("blenderbot-small", "BlenderbotSmall"), | |
("blip", "BLIP"), | |
("blip-2", "BLIP-2"), | |
("bloom", "BLOOM"), | |
("bort", "BORT"), | |
("bridgetower", "BridgeTower"), | |
("bros", "BROS"), | |
("byt5", "ByT5"), | |
("camembert", "CamemBERT"), | |
("canine", "CANINE"), | |
("chinese_clip", "Chinese-CLIP"), | |
("clap", "CLAP"), | |
("clip", "CLIP"), | |
("clipseg", "CLIPSeg"), | |
("code_llama", "CodeLlama"), | |
("codegen", "CodeGen"), | |
("conditional_detr", "Conditional DETR"), | |
("convbert", "ConvBERT"), | |
("convnext", "ConvNeXT"), | |
("convnextv2", "ConvNeXTV2"), | |
("cpm", "CPM"), | |
("cpmant", "CPM-Ant"), | |
("ctrl", "CTRL"), | |
("cvt", "CvT"), | |
("data2vec-audio", "Data2VecAudio"), | |
("data2vec-text", "Data2VecText"), | |
("data2vec-vision", "Data2VecVision"), | |
("deberta", "DeBERTa"), | |
("deberta-v2", "DeBERTa-v2"), | |
("decision_transformer", "Decision Transformer"), | |
("deformable_detr", "Deformable DETR"), | |
("deit", "DeiT"), | |
("deplot", "DePlot"), | |
("deta", "DETA"), | |
("detr", "DETR"), | |
("dialogpt", "DialoGPT"), | |
("dinat", "DiNAT"), | |
("dinov2", "DINOv2"), | |
("distilbert", "DistilBERT"), | |
("dit", "DiT"), | |
("donut-swin", "DonutSwin"), | |
("dpr", "DPR"), | |
("dpt", "DPT"), | |
("efficientformer", "EfficientFormer"), | |
("efficientnet", "EfficientNet"), | |
("electra", "ELECTRA"), | |
("encodec", "EnCodec"), | |
("encoder-decoder", "Encoder decoder"), | |
("ernie", "ERNIE"), | |
("ernie_m", "ErnieM"), | |
("esm", "ESM"), | |
("falcon", "Falcon"), | |
("flan-t5", "FLAN-T5"), | |
("flan-ul2", "FLAN-UL2"), | |
("flaubert", "FlauBERT"), | |
("flava", "FLAVA"), | |
("fnet", "FNet"), | |
("focalnet", "FocalNet"), | |
("fsmt", "FairSeq Machine-Translation"), | |
("funnel", "Funnel Transformer"), | |
("git", "GIT"), | |
("glpn", "GLPN"), | |
("gpt-sw3", "GPT-Sw3"), | |
("gpt2", "OpenAI GPT-2"), | |
("gpt_bigcode", "GPTBigCode"), | |
("gpt_neo", "GPT Neo"), | |
("gpt_neox", "GPT NeoX"), | |
("gpt_neox_japanese", "GPT NeoX Japanese"), | |
("gptj", "GPT-J"), | |
("gptsan-japanese", "GPTSAN-japanese"), | |
("graphormer", "Graphormer"), | |
("groupvit", "GroupViT"), | |
("herbert", "HerBERT"), | |
("hubert", "Hubert"), | |
("ibert", "I-BERT"), | |
("idefics", "IDEFICS"), | |
("imagegpt", "ImageGPT"), | |
("informer", "Informer"), | |
("instructblip", "InstructBLIP"), | |
("jukebox", "Jukebox"), | |
("layoutlm", "LayoutLM"), | |
("layoutlmv2", "LayoutLMv2"), | |
("layoutlmv3", "LayoutLMv3"), | |
("layoutxlm", "LayoutXLM"), | |
("led", "LED"), | |
("levit", "LeViT"), | |
("lilt", "LiLT"), | |
("llama", "LLaMA"), | |
("llama2", "Llama2"), | |
("longformer", "Longformer"), | |
("longt5", "LongT5"), | |
("luke", "LUKE"), | |
("lxmert", "LXMERT"), | |
("m2m_100", "M2M100"), | |
("marian", "Marian"), | |
("markuplm", "MarkupLM"), | |
("mask2former", "Mask2Former"), | |
("maskformer", "MaskFormer"), | |
("maskformer-swin", "MaskFormerSwin"), | |
("matcha", "MatCha"), | |
("mbart", "mBART"), | |
("mbart50", "mBART-50"), | |
("mctct", "M-CTC-T"), | |
("mega", "MEGA"), | |
("megatron-bert", "Megatron-BERT"), | |
("megatron_gpt2", "Megatron-GPT2"), | |
("mgp-str", "MGP-STR"), | |
("mistral", "Mistral"), | |
("mluke", "mLUKE"), | |
("mms", "MMS"), | |
("mobilebert", "MobileBERT"), | |
("mobilenet_v1", "MobileNetV1"), | |
("mobilenet_v2", "MobileNetV2"), | |
("mobilevit", "MobileViT"), | |
("mobilevitv2", "MobileViTV2"), | |
("mpnet", "MPNet"), | |
("mpt", "MPT"), | |
("mra", "MRA"), | |
("mt5", "MT5"), | |
("musicgen", "MusicGen"), | |
("mvp", "MVP"), | |
("nat", "NAT"), | |
("nezha", "Nezha"), | |
("nllb", "NLLB"), | |
("nllb-moe", "NLLB-MOE"), | |
("nougat", "Nougat"), | |
("nystromformer", "Nyströmformer"), | |
("oneformer", "OneFormer"), | |
("open-llama", "OpenLlama"), | |
("openai-gpt", "OpenAI GPT"), | |
("opt", "OPT"), | |
("owlvit", "OWL-ViT"), | |
("pegasus", "Pegasus"), | |
("pegasus_x", "PEGASUS-X"), | |
("perceiver", "Perceiver"), | |
("persimmon", "Persimmon"), | |
("phobert", "PhoBERT"), | |
("pix2struct", "Pix2Struct"), | |
("plbart", "PLBart"), | |
("poolformer", "PoolFormer"), | |
("pop2piano", "Pop2Piano"), | |
("prophetnet", "ProphetNet"), | |
("pvt", "PVT"), | |
("qdqbert", "QDQBert"), | |
("rag", "RAG"), | |
("realm", "REALM"), | |
("reformer", "Reformer"), | |
("regnet", "RegNet"), | |
("rembert", "RemBERT"), | |
("resnet", "ResNet"), | |
("retribert", "RetriBERT"), | |
("roberta", "RoBERTa"), | |
("roberta-prelayernorm", "RoBERTa-PreLayerNorm"), | |
("roc_bert", "RoCBert"), | |
("roformer", "RoFormer"), | |
("rwkv", "RWKV"), | |
("sam", "SAM"), | |
("segformer", "SegFormer"), | |
("sew", "SEW"), | |
("sew-d", "SEW-D"), | |
("speech-encoder-decoder", "Speech Encoder decoder"), | |
("speech_to_text", "Speech2Text"), | |
("speech_to_text_2", "Speech2Text2"), | |
("speecht5", "SpeechT5"), | |
("splinter", "Splinter"), | |
("squeezebert", "SqueezeBERT"), | |
("swiftformer", "SwiftFormer"), | |
("swin", "Swin Transformer"), | |
("swin2sr", "Swin2SR"), | |
("swinv2", "Swin Transformer V2"), | |
("switch_transformers", "SwitchTransformers"), | |
("t5", "T5"), | |
("t5v1.1", "T5v1.1"), | |
("table-transformer", "Table Transformer"), | |
("tapas", "TAPAS"), | |
("tapex", "TAPEX"), | |
("time_series_transformer", "Time Series Transformer"), | |
("timesformer", "TimeSformer"), | |
("timm_backbone", "TimmBackbone"), | |
("trajectory_transformer", "Trajectory Transformer"), | |
("transfo-xl", "Transformer-XL"), | |
("trocr", "TrOCR"), | |
("tvlt", "TVLT"), | |
("ul2", "UL2"), | |
("umt5", "UMT5"), | |
("unispeech", "UniSpeech"), | |
("unispeech-sat", "UniSpeechSat"), | |
("upernet", "UPerNet"), | |
("van", "VAN"), | |
("videomae", "VideoMAE"), | |
("vilt", "ViLT"), | |
("vision-encoder-decoder", "Vision Encoder decoder"), | |
("vision-text-dual-encoder", "VisionTextDualEncoder"), | |
("visual_bert", "VisualBERT"), | |
("vit", "ViT"), | |
("vit_hybrid", "ViT Hybrid"), | |
("vit_mae", "ViTMAE"), | |
("vit_msn", "ViTMSN"), | |
("vitdet", "VitDet"), | |
("vitmatte", "ViTMatte"), | |
("vits", "VITS"), | |
("vivit", "ViViT"), | |
("wav2vec2", "Wav2Vec2"), | |
("wav2vec2-conformer", "Wav2Vec2-Conformer"), | |
("wav2vec2_phoneme", "Wav2Vec2Phoneme"), | |
("wavlm", "WavLM"), | |
("whisper", "Whisper"), | |
("xclip", "X-CLIP"), | |
("xglm", "XGLM"), | |
("xlm", "XLM"), | |
("xlm-prophetnet", "XLM-ProphetNet"), | |
("xlm-roberta", "XLM-RoBERTa"), | |
("xlm-roberta-xl", "XLM-RoBERTa-XL"), | |
("xlm-v", "XLM-V"), | |
("xlnet", "XLNet"), | |
("xls_r", "XLS-R"), | |
("xlsr_wav2vec2", "XLSR-Wav2Vec2"), | |
("xmod", "X-MOD"), | |
("yolos", "YOLOS"), | |
("yoso", "YOSO"), | |
] | |
) | |
DEPRECATED_MODELS = [ | |
"bort", | |
"mctct", | |
"mmbt", | |
"open_llama", | |
"retribert", | |
"tapex", | |
"trajectory_transformer", | |
"van", | |
] | |
SPECIAL_MODEL_TYPE_TO_MODULE_NAME = OrderedDict( | |
[ | |
("openai-gpt", "openai"), | |
("data2vec-audio", "data2vec"), | |
("data2vec-text", "data2vec"), | |
("data2vec-vision", "data2vec"), | |
("donut-swin", "donut"), | |
("maskformer-swin", "maskformer"), | |
("xclip", "x_clip"), | |
] | |
) | |
def model_type_to_module_name(key): | |
"""Converts a config key to the corresponding module.""" | |
# Special treatment | |
if key in SPECIAL_MODEL_TYPE_TO_MODULE_NAME: | |
return SPECIAL_MODEL_TYPE_TO_MODULE_NAME[key] | |
key = key.replace("-", "_") | |
if key in DEPRECATED_MODELS: | |
key = f"deprecated.{key}" | |
return key | |
def config_class_to_model_type(config): | |
"""Converts a config class name to the corresponding model type""" | |
for key, cls in CONFIG_MAPPING_NAMES.items(): | |
if cls == config: | |
return key | |
# if key not found check in extra content | |
for key, cls in CONFIG_MAPPING._extra_content.items(): | |
if cls.__name__ == config: | |
return key | |
return None | |
class _LazyConfigMapping(OrderedDict): | |
""" | |
A dictionary that lazily load its values when they are requested. | |
""" | |
def __init__(self, mapping): | |
self._mapping = mapping | |
self._extra_content = {} | |
self._modules = {} | |
def __getitem__(self, key): | |
if key in self._extra_content: | |
return self._extra_content[key] | |
if key not in self._mapping: | |
raise KeyError(key) | |
value = self._mapping[key] | |
module_name = model_type_to_module_name(key) | |
if module_name not in self._modules: | |
self._modules[module_name] = importlib.import_module(f".{module_name}", "transformers.models") | |
if hasattr(self._modules[module_name], value): | |
return getattr(self._modules[module_name], value) | |
# Some of the mappings have entries model_type -> config of another model type. In that case we try to grab the | |
# object at the top level. | |
transformers_module = importlib.import_module("transformers") | |
return getattr(transformers_module, value) | |
def keys(self): | |
return list(self._mapping.keys()) + list(self._extra_content.keys()) | |
def values(self): | |
return [self[k] for k in self._mapping.keys()] + list(self._extra_content.values()) | |
def items(self): | |
return [(k, self[k]) for k in self._mapping.keys()] + list(self._extra_content.items()) | |
def __iter__(self): | |
return iter(list(self._mapping.keys()) + list(self._extra_content.keys())) | |
def __contains__(self, item): | |
return item in self._mapping or item in self._extra_content | |
def register(self, key, value, exist_ok=False): | |
""" | |
Register a new configuration in this mapping. | |
""" | |
if key in self._mapping.keys() and not exist_ok: | |
raise ValueError(f"'{key}' is already used by a Transformers config, pick another name.") | |
self._extra_content[key] = value | |
CONFIG_MAPPING = _LazyConfigMapping(CONFIG_MAPPING_NAMES) | |
class _LazyLoadAllMappings(OrderedDict): | |
""" | |
A mapping that will load all pairs of key values at the first access (either by indexing, requestions keys, values, | |
etc.) | |
Args: | |
mapping: The mapping to load. | |
""" | |
def __init__(self, mapping): | |
self._mapping = mapping | |
self._initialized = False | |
self._data = {} | |
def _initialize(self): | |
if self._initialized: | |
return | |
warnings.warn( | |
"ALL_PRETRAINED_CONFIG_ARCHIVE_MAP is deprecated and will be removed in v5 of Transformers. " | |
"It does not contain all available model checkpoints, far from it. Checkout hf.co/models for that.", | |
FutureWarning, | |
) | |
for model_type, map_name in self._mapping.items(): | |
module_name = model_type_to_module_name(model_type) | |
module = importlib.import_module(f".{module_name}", "transformers.models") | |
mapping = getattr(module, map_name) | |
self._data.update(mapping) | |
self._initialized = True | |
def __getitem__(self, key): | |
self._initialize() | |
return self._data[key] | |
def keys(self): | |
self._initialize() | |
return self._data.keys() | |
def values(self): | |
self._initialize() | |
return self._data.values() | |
def items(self): | |
self._initialize() | |
return self._data.keys() | |
def __iter__(self): | |
self._initialize() | |
return iter(self._data) | |
def __contains__(self, item): | |
self._initialize() | |
return item in self._data | |
ALL_PRETRAINED_CONFIG_ARCHIVE_MAP = _LazyLoadAllMappings(CONFIG_ARCHIVE_MAP_MAPPING_NAMES) | |
def _get_class_name(model_class: Union[str, List[str]]): | |
if isinstance(model_class, (list, tuple)): | |
return " or ".join([f"[`{c}`]" for c in model_class if c is not None]) | |
return f"[`{model_class}`]" | |
def _list_model_options(indent, config_to_class=None, use_model_types=True): | |
if config_to_class is None and not use_model_types: | |
raise ValueError("Using `use_model_types=False` requires a `config_to_class` dictionary.") | |
if use_model_types: | |
if config_to_class is None: | |
model_type_to_name = {model_type: f"[`{config}`]" for model_type, config in CONFIG_MAPPING_NAMES.items()} | |
else: | |
model_type_to_name = { | |
model_type: _get_class_name(model_class) | |
for model_type, model_class in config_to_class.items() | |
if model_type in MODEL_NAMES_MAPPING | |
} | |
lines = [ | |
f"{indent}- **{model_type}** -- {model_type_to_name[model_type]} ({MODEL_NAMES_MAPPING[model_type]} model)" | |
for model_type in sorted(model_type_to_name.keys()) | |
] | |
else: | |
config_to_name = { | |
CONFIG_MAPPING_NAMES[config]: _get_class_name(clas) | |
for config, clas in config_to_class.items() | |
if config in CONFIG_MAPPING_NAMES | |
} | |
config_to_model_name = { | |
config: MODEL_NAMES_MAPPING[model_type] for model_type, config in CONFIG_MAPPING_NAMES.items() | |
} | |
lines = [ | |
f"{indent}- [`{config_name}`] configuration class:" | |
f" {config_to_name[config_name]} ({config_to_model_name[config_name]} model)" | |
for config_name in sorted(config_to_name.keys()) | |
] | |
return "\n".join(lines) | |
def replace_list_option_in_docstrings(config_to_class=None, use_model_types=True): | |
def docstring_decorator(fn): | |
docstrings = fn.__doc__ | |
lines = docstrings.split("\n") | |
i = 0 | |
while i < len(lines) and re.search(r"^(\s*)List options\s*$", lines[i]) is None: | |
i += 1 | |
if i < len(lines): | |
indent = re.search(r"^(\s*)List options\s*$", lines[i]).groups()[0] | |
if use_model_types: | |
indent = f"{indent} " | |
lines[i] = _list_model_options(indent, config_to_class=config_to_class, use_model_types=use_model_types) | |
docstrings = "\n".join(lines) | |
else: | |
raise ValueError( | |
f"The function {fn} should have an empty 'List options' in its docstring as placeholder, current" | |
f" docstring is:\n{docstrings}" | |
) | |
fn.__doc__ = docstrings | |
return fn | |
return docstring_decorator | |
class AutoConfig: | |
r""" | |
This is a generic configuration class that will be instantiated as one of the configuration classes of the library | |
when created with the [`~AutoConfig.from_pretrained`] class method. | |
This class cannot be instantiated directly using `__init__()` (throws an error). | |
""" | |
def __init__(self): | |
raise EnvironmentError( | |
"AutoConfig is designed to be instantiated " | |
"using the `AutoConfig.from_pretrained(pretrained_model_name_or_path)` method." | |
) | |
def for_model(cls, model_type: str, *args, **kwargs): | |
if model_type in CONFIG_MAPPING: | |
config_class = CONFIG_MAPPING[model_type] | |
return config_class(*args, **kwargs) | |
raise ValueError( | |
f"Unrecognized model identifier: {model_type}. Should contain one of {', '.join(CONFIG_MAPPING.keys())}" | |
) | |
def from_pretrained(cls, pretrained_model_name_or_path, **kwargs): | |
r""" | |
Instantiate one of the configuration classes of the library from a pretrained model configuration. | |
The configuration class to instantiate is selected based on the `model_type` property of the config object that | |
is loaded, or when it's missing, by falling back to using pattern matching on `pretrained_model_name_or_path`: | |
List options | |
Args: | |
pretrained_model_name_or_path (`str` or `os.PathLike`): | |
Can be either: | |
- A string, the *model id* of a pretrained model configuration hosted inside a model repo on | |
huggingface.co. Valid model ids can be located at the root-level, like `bert-base-uncased`, or | |
namespaced under a user or organization name, like `dbmdz/bert-base-german-cased`. | |
- A path to a *directory* containing a configuration file saved using the | |
[`~PretrainedConfig.save_pretrained`] method, or the [`~PreTrainedModel.save_pretrained`] method, | |
e.g., `./my_model_directory/`. | |
- A path or url to a saved configuration JSON *file*, e.g., | |
`./my_model_directory/configuration.json`. | |
cache_dir (`str` or `os.PathLike`, *optional*): | |
Path to a directory in which a downloaded pretrained model configuration should be cached if the | |
standard cache should not be used. | |
force_download (`bool`, *optional*, defaults to `False`): | |
Whether or not to force the (re-)download the model weights and configuration files and override the | |
cached versions if they exist. | |
resume_download (`bool`, *optional*, defaults to `False`): | |
Whether or not to delete incompletely received files. Will attempt to resume the download if such a | |
file exists. | |
proxies (`Dict[str, str]`, *optional*): | |
A dictionary of proxy servers to use by protocol or endpoint, e.g., `{'http': 'foo.bar:3128', | |
'http://hostname': 'foo.bar:4012'}`. The proxies are used on each request. | |
revision (`str`, *optional*, defaults to `"main"`): | |
The specific model version to use. It can be a branch name, a tag name, or a commit id, since we use a | |
git-based system for storing models and other artifacts on huggingface.co, so `revision` can be any | |
identifier allowed by git. | |
return_unused_kwargs (`bool`, *optional*, defaults to `False`): | |
If `False`, then this function returns just the final configuration object. | |
If `True`, then this functions returns a `Tuple(config, unused_kwargs)` where *unused_kwargs* is a | |
dictionary consisting of the key/value pairs whose keys are not configuration attributes: i.e., the | |
part of `kwargs` which has not been used to update `config` and is otherwise ignored. | |
trust_remote_code (`bool`, *optional*, defaults to `False`): | |
Whether or not to allow for custom models defined on the Hub in their own modeling files. This option | |
should only be set to `True` for repositories you trust and in which you have read the code, as it will | |
execute code present on the Hub on your local machine. | |
kwargs(additional keyword arguments, *optional*): | |
The values in kwargs of any keys which are configuration attributes will be used to override the loaded | |
values. Behavior concerning key/value pairs whose keys are *not* configuration attributes is controlled | |
by the `return_unused_kwargs` keyword parameter. | |
Examples: | |
```python | |
>>> from transformers import AutoConfig | |
>>> # Download configuration from huggingface.co and cache. | |
>>> config = AutoConfig.from_pretrained("bert-base-uncased") | |
>>> # Download configuration from huggingface.co (user-uploaded) and cache. | |
>>> config = AutoConfig.from_pretrained("dbmdz/bert-base-german-cased") | |
>>> # If configuration file is in a directory (e.g., was saved using *save_pretrained('./test/saved_model/')*). | |
>>> config = AutoConfig.from_pretrained("./test/bert_saved_model/") | |
>>> # Load a specific configuration file. | |
>>> config = AutoConfig.from_pretrained("./test/bert_saved_model/my_configuration.json") | |
>>> # Change some config attributes when loading a pretrained config. | |
>>> config = AutoConfig.from_pretrained("bert-base-uncased", output_attentions=True, foo=False) | |
>>> config.output_attentions | |
True | |
>>> config, unused_kwargs = AutoConfig.from_pretrained( | |
... "bert-base-uncased", output_attentions=True, foo=False, return_unused_kwargs=True | |
... ) | |
>>> config.output_attentions | |
True | |
>>> unused_kwargs | |
{'foo': False} | |
```""" | |
use_auth_token = kwargs.pop("use_auth_token", None) | |
if use_auth_token is not None: | |
warnings.warn( | |
"The `use_auth_token` argument is deprecated and will be removed in v5 of Transformers.", FutureWarning | |
) | |
if kwargs.get("token", None) is not None: | |
raise ValueError( | |
"`token` and `use_auth_token` are both specified. Please set only the argument `token`." | |
) | |
kwargs["token"] = use_auth_token | |
kwargs["_from_auto"] = True | |
kwargs["name_or_path"] = pretrained_model_name_or_path | |
trust_remote_code = kwargs.pop("trust_remote_code", None) | |
code_revision = kwargs.pop("code_revision", None) | |
config_dict, unused_kwargs = PretrainedConfig.get_config_dict(pretrained_model_name_or_path, **kwargs) | |
has_remote_code = "auto_map" in config_dict and "AutoConfig" in config_dict["auto_map"] | |
has_local_code = "model_type" in config_dict and config_dict["model_type"] in CONFIG_MAPPING | |
trust_remote_code = resolve_trust_remote_code( | |
trust_remote_code, pretrained_model_name_or_path, has_local_code, has_remote_code | |
) | |
if has_remote_code and trust_remote_code: | |
class_ref = config_dict["auto_map"]["AutoConfig"] | |
config_class = get_class_from_dynamic_module( | |
class_ref, pretrained_model_name_or_path, code_revision=code_revision, **kwargs | |
) | |
if os.path.isdir(pretrained_model_name_or_path): | |
config_class.register_for_auto_class() | |
return config_class.from_pretrained(pretrained_model_name_or_path, **kwargs) | |
elif "model_type" in config_dict: | |
config_class = CONFIG_MAPPING[config_dict["model_type"]] | |
return config_class.from_dict(config_dict, **unused_kwargs) | |
else: | |
# Fallback: use pattern matching on the string. | |
# We go from longer names to shorter names to catch roberta before bert (for instance) | |
for pattern in sorted(CONFIG_MAPPING.keys(), key=len, reverse=True): | |
if pattern in str(pretrained_model_name_or_path): | |
return CONFIG_MAPPING[pattern].from_dict(config_dict, **unused_kwargs) | |
raise ValueError( | |
f"Unrecognized model in {pretrained_model_name_or_path}. " | |
f"Should have a `model_type` key in its {CONFIG_NAME}, or contain one of the following strings " | |
f"in its name: {', '.join(CONFIG_MAPPING.keys())}" | |
) | |
def register(model_type, config, exist_ok=False): | |
""" | |
Register a new configuration for this class. | |
Args: | |
model_type (`str`): The model type like "bert" or "gpt". | |
config ([`PretrainedConfig`]): The config to register. | |
""" | |
if issubclass(config, PretrainedConfig) and config.model_type != model_type: | |
raise ValueError( | |
"The config you are passing has a `model_type` attribute that is not consistent with the model type " | |
f"you passed (config has {config.model_type} and you passed {model_type}. Fix one of those so they " | |
"match!" | |
) | |
CONFIG_MAPPING.register(model_type, config, exist_ok=exist_ok) | |