Transformers
  • 🌍GET STARTED
    • Transformers
    • Quick tour
    • Installation
  • 🌍TUTORIALS
    • Run inference with pipelines
    • Write portable code with AutoClass
    • Preprocess data
    • Fine-tune a pretrained model
    • Train with a script
    • Set up distributed training with BOINC AI Accelerate
    • Load and train adapters with BOINC AI PEFT
    • Share your model
    • Agents
    • Generation with LLMs
  • 🌍TASK GUIDES
    • 🌍NATURAL LANGUAGE PROCESSING
      • Text classification
      • Token classification
      • Question answering
      • Causal language modeling
      • Masked language modeling
      • Translation
      • Summarization
      • Multiple choice
    • 🌍AUDIO
      • Audio classification
      • Automatic speech recognition
    • 🌍COMPUTER VISION
      • Image classification
      • Semantic segmentation
      • Video classification
      • Object detection
      • Zero-shot object detection
      • Zero-shot image classification
      • Depth estimation
    • 🌍MULTIMODAL
      • Image captioning
      • Document Question Answering
      • Visual Question Answering
      • Text to speech
    • 🌍GENERATION
      • Customize the generation strategy
    • 🌍PROMPTING
      • Image tasks with IDEFICS
  • 🌍DEVELOPER GUIDES
    • Use fast tokenizers from BOINC AI Tokenizers
    • Run inference with multilingual models
    • Use model-specific APIs
    • Share a custom model
    • Templates for chat models
    • Run training on Amazon SageMaker
    • Export to ONNX
    • Export to TFLite
    • Export to TorchScript
    • Benchmarks
    • Notebooks with examples
    • Community resources
    • Custom Tools and Prompts
    • Troubleshoot
  • 🌍PERFORMANCE AND SCALABILITY
    • Overview
    • 🌍EFFICIENT TRAINING TECHNIQUES
      • Methods and tools for efficient training on a single GPU
      • Multiple GPUs and parallelism
      • Efficient training on CPU
      • Distributed CPU training
      • Training on TPUs
      • Training on TPU with TensorFlow
      • Training on Specialized Hardware
      • Custom hardware for training
      • Hyperparameter Search using Trainer API
    • 🌍OPTIMIZING INFERENCE
      • Inference on CPU
      • Inference on one GPU
      • Inference on many GPUs
      • Inference on Specialized Hardware
    • Instantiating a big model
    • Troubleshooting
    • XLA Integration for TensorFlow Models
    • Optimize inference using `torch.compile()`
  • 🌍CONTRIBUTE
    • How to contribute to transformers?
    • How to add a model to BOINC AI Transformers?
    • How to convert a BOINC AI Transformers model to TensorFlow?
    • How to add a pipeline to BOINC AI Transformers?
    • Testing
    • Checks on a Pull Request
  • 🌍CONCEPTUAL GUIDES
    • Philosophy
    • Glossary
    • What BOINC AI Transformers can do
    • How BOINC AI Transformers solve tasks
    • The Transformer model family
    • Summary of the tokenizers
    • Attention mechanisms
    • Padding and truncation
    • BERTology
    • Perplexity of fixed-length models
    • Pipelines for webserver inference
    • Model training anatomy
  • 🌍API
    • 🌍MAIN CLASSES
      • Agents and Tools
      • 🌍Auto Classes
        • Extending the Auto Classes
        • AutoConfig
        • AutoTokenizer
        • AutoFeatureExtractor
        • AutoImageProcessor
        • AutoProcessor
        • Generic model classes
          • AutoModel
          • TFAutoModel
          • FlaxAutoModel
        • Generic pretraining classes
          • AutoModelForPreTraining
          • TFAutoModelForPreTraining
          • FlaxAutoModelForPreTraining
        • Natural Language Processing
          • AutoModelForCausalLM
          • TFAutoModelForCausalLM
          • FlaxAutoModelForCausalLM
          • AutoModelForMaskedLM
          • TFAutoModelForMaskedLM
          • FlaxAutoModelForMaskedLM
          • AutoModelForMaskGenerationge
          • TFAutoModelForMaskGeneration
          • AutoModelForSeq2SeqLM
          • TFAutoModelForSeq2SeqLM
          • FlaxAutoModelForSeq2SeqLM
          • AutoModelForSequenceClassification
          • TFAutoModelForSequenceClassification
          • FlaxAutoModelForSequenceClassification
          • AutoModelForMultipleChoice
          • TFAutoModelForMultipleChoice
          • FlaxAutoModelForMultipleChoice
          • AutoModelForNextSentencePrediction
          • TFAutoModelForNextSentencePrediction
          • FlaxAutoModelForNextSentencePrediction
          • AutoModelForTokenClassification
          • TFAutoModelForTokenClassification
          • FlaxAutoModelForTokenClassification
          • AutoModelForQuestionAnswering
          • TFAutoModelForQuestionAnswering
          • FlaxAutoModelForQuestionAnswering
          • AutoModelForTextEncoding
          • TFAutoModelForTextEncoding
        • Computer vision
          • AutoModelForDepthEstimation
          • AutoModelForImageClassification
          • TFAutoModelForImageClassification
          • FlaxAutoModelForImageClassification
          • AutoModelForVideoClassification
          • AutoModelForMaskedImageModeling
          • TFAutoModelForMaskedImageModeling
          • AutoModelForObjectDetection
          • AutoModelForImageSegmentation
          • AutoModelForImageToImage
          • AutoModelForSemanticSegmentation
          • TFAutoModelForSemanticSegmentation
          • AutoModelForInstanceSegmentation
          • AutoModelForUniversalSegmentation
          • AutoModelForZeroShotImageClassification
          • TFAutoModelForZeroShotImageClassification
          • AutoModelForZeroShotObjectDetection
        • Audio
          • AutoModelForAudioClassification
          • AutoModelForAudioFrameClassification
          • TFAutoModelForAudioFrameClassification
          • AutoModelForCTC
          • AutoModelForSpeechSeq2Seq
          • TFAutoModelForSpeechSeq2Seq
          • FlaxAutoModelForSpeechSeq2Seq
          • AutoModelForAudioXVector
          • AutoModelForTextToSpectrogram
          • AutoModelForTextToWaveform
        • Multimodal
          • AutoModelForTableQuestionAnswering
          • TFAutoModelForTableQuestionAnswering
          • AutoModelForDocumentQuestionAnswering
          • TFAutoModelForDocumentQuestionAnswering
          • AutoModelForVisualQuestionAnswering
          • AutoModelForVision2Seq
          • TFAutoModelForVision2Seq
          • FlaxAutoModelForVision2Seq
      • Callbacks
      • Configuration
      • Data Collator
      • Keras callbacks
      • Logging
      • Models
      • Text Generation
      • ONNX
      • Optimization
      • Model outputs
      • Pipelines
      • Processors
      • Quantization
      • Tokenizer
      • Trainer
      • DeepSpeed Integration
      • Feature Extractor
      • Image Processor
    • 🌍MODELS
      • 🌍TEXT MODELS
        • ALBERT
        • BART
        • BARThez
        • BARTpho
        • BERT
        • BertGeneration
        • BertJapanese
        • Bertweet
        • BigBird
        • BigBirdPegasus
        • BioGpt
        • Blenderbot
        • Blenderbot Small
        • BLOOM
        • BORT
        • ByT5
        • CamemBERT
        • CANINE
        • CodeGen
        • CodeLlama
        • ConvBERT
        • CPM
        • CPMANT
        • CTRL
        • DeBERTa
        • DeBERTa-v2
        • DialoGPT
        • DistilBERT
        • DPR
        • ELECTRA
        • Encoder Decoder Models
        • ERNIE
        • ErnieM
        • ESM
        • Falcon
        • FLAN-T5
        • FLAN-UL2
        • FlauBERT
        • FNet
        • FSMT
        • Funnel Transformer
        • GPT
        • GPT Neo
        • GPT NeoX
        • GPT NeoX Japanese
        • GPT-J
        • GPT2
        • GPTBigCode
        • GPTSAN Japanese
        • GPTSw3
        • HerBERT
        • I-BERT
        • Jukebox
        • LED
        • LLaMA
        • LLama2
        • Longformer
        • LongT5
        • LUKE
        • M2M100
        • MarianMT
        • MarkupLM
        • MBart and MBart-50
        • MEGA
        • MegatronBERT
        • MegatronGPT2
        • Mistral
        • mLUKE
        • MobileBERT
        • MPNet
        • MPT
        • MRA
        • MT5
        • MVP
        • NEZHA
        • NLLB
        • NLLB-MoE
        • Nyströmformer
        • Open-Llama
        • OPT
        • Pegasus
        • PEGASUS-X
        • Persimmon
        • PhoBERT
        • PLBart
        • ProphetNet
        • QDQBert
        • RAG
        • REALM
        • Reformer
        • RemBERT
        • RetriBERT
        • RoBERTa
        • RoBERTa-PreLayerNorm
        • RoCBert
        • RoFormer
        • RWKV
        • Splinter
        • SqueezeBERT
        • SwitchTransformers
        • T5
        • T5v1.1
        • TAPEX
        • Transformer XL
        • UL2
        • UMT5
        • X-MOD
        • XGLM
        • XLM
        • XLM-ProphetNet
        • XLM-RoBERTa
        • XLM-RoBERTa-XL
        • XLM-V
        • XLNet
        • YOSO
      • 🌍VISION MODELS
        • BEiT
        • BiT
        • Conditional DETR
        • ConvNeXT
        • ConvNeXTV2
        • CvT
        • Deformable DETR
        • DeiT
        • DETA
        • DETR
        • DiNAT
        • DINO V2
        • DiT
        • DPT
        • EfficientFormer
        • EfficientNet
        • FocalNet
        • GLPN
        • ImageGPT
        • LeViT
        • Mask2Former
        • MaskFormer
        • MobileNetV1
        • MobileNetV2
        • MobileViT
        • MobileViTV2
        • NAT
        • PoolFormer
        • Pyramid Vision Transformer (PVT)
        • RegNet
        • ResNet
        • SegFormer
        • SwiftFormer
        • Swin Transformer
        • Swin Transformer V2
        • Swin2SR
        • Table Transformer
        • TimeSformer
        • UperNet
        • VAN
        • VideoMAE
        • Vision Transformer (ViT)
        • ViT Hybrid
        • ViTDet
        • ViTMAE
        • ViTMatte
        • ViTMSN
        • ViViT
        • YOLOS
      • 🌍AUDIO MODELS
        • Audio Spectrogram Transformer
        • Bark
        • CLAP
        • EnCodec
        • Hubert
        • MCTCT
        • MMS
        • MusicGen
        • Pop2Piano
        • SEW
        • SEW-D
        • Speech2Text
        • Speech2Text2
        • SpeechT5
        • UniSpeech
        • UniSpeech-SAT
        • VITS
        • Wav2Vec2
        • Wav2Vec2-Conformer
        • Wav2Vec2Phoneme
        • WavLM
        • Whisper
        • XLS-R
        • XLSR-Wav2Vec2
      • 🌍MULTIMODAL MODELS
        • ALIGN
        • AltCLIP
        • BLIP
        • BLIP-2
        • BridgeTower
        • BROS
        • Chinese-CLIP
        • CLIP
        • CLIPSeg
        • Data2Vec
        • DePlot
        • Donut
        • FLAVA
        • GIT
        • GroupViT
        • IDEFICS
        • InstructBLIP
        • LayoutLM
        • LayoutLMV2
        • LayoutLMV3
        • LayoutXLM
        • LiLT
        • LXMERT
        • MatCha
        • MGP-STR
        • Nougat
        • OneFormer
        • OWL-ViT
        • Perceiver
        • Pix2Struct
        • Segment Anything
        • Speech Encoder Decoder Models
        • TAPAS
        • TrOCR
        • TVLT
        • ViLT
        • Vision Encoder Decoder Models
        • Vision Text Dual Encoder
        • VisualBERT
        • X-CLIP
      • 🌍REINFORCEMENT LEARNING MODELS
        • Decision Transformer
        • Trajectory Transformer
      • 🌍TIME SERIES MODELS
        • Autoformer
        • Informer
        • Time Series Transformer
      • 🌍GRAPH MODELS
        • Graphormer
  • 🌍INTERNAL HELPERS
    • Custom Layers and Utilities
    • Utilities for pipelines
    • Utilities for Tokenizers
    • Utilities for Trainer
    • Utilities for Generation
    • Utilities for Image Processors
    • Utilities for Audio processing
    • General Utilities
    • Utilities for Time Series
Powered by GitBook
On this page
  1. API
  2. MAIN CLASSES
  3. Auto Classes

AutoConfig

PreviousExtending the Auto ClassesNextAutoTokenizer

Last updated 1 year ago

AutoConfig

class transformers.AutoConfig

( )

This is a generic configuration class that will be instantiated as one of the configuration classes of the library when created with the class method.

This class cannot be instantiated directly using __init__() (throws an error).

from_pretrained

( pretrained_model_name_or_path**kwargs )

Parameters

  • 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 method, or the 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.

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:

  • maskformer-swin — MaskFormerSwinConfig (MaskFormerSwin model)

  • timm_backbone — TimmBackboneConfig (TimmBackbone model)

Examples:

Copied

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

register

( model_typeconfigexist_ok = False )

Parameters

  • model_type (str) — The model type like “bert” or “gpt”.

Register a new configuration for this class.

albert — (ALBERT model)

align — (ALIGN model)

altclip — (AltCLIP model)

audio-spectrogram-transformer — (Audio Spectrogram Transformer model)

autoformer — (Autoformer model)

bark — (Bark model)

bart — (BART model)

beit — (BEiT model)

bert — (BERT model)

bert-generation — (Bert Generation model)

big_bird — (BigBird model)

bigbird_pegasus — (BigBird-Pegasus model)

biogpt — (BioGpt model)

bit — (BiT model)

blenderbot — (Blenderbot model)

blenderbot-small — (BlenderbotSmall model)

blip — (BLIP model)

blip-2 — (BLIP-2 model)

bloom — (BLOOM model)

bridgetower — (BridgeTower model)

bros — (BROS model)

camembert — (CamemBERT model)

canine — (CANINE model)

chinese_clip — (Chinese-CLIP model)

clap — (CLAP model)

clip — (CLIP model)

clipseg — (CLIPSeg model)

code_llama — (CodeLlama model)

codegen — (CodeGen model)

conditional_detr — (Conditional DETR model)

convbert — (ConvBERT model)

convnext — (ConvNeXT model)

convnextv2 — (ConvNeXTV2 model)

cpmant — (CPM-Ant model)

ctrl — (CTRL model)

cvt — (CvT model)

data2vec-audio — (Data2VecAudio model)

data2vec-text — (Data2VecText model)

data2vec-vision — (Data2VecVision model)

deberta — (DeBERTa model)

deberta-v2 — (DeBERTa-v2 model)

decision_transformer — (Decision Transformer model)

deformable_detr — (Deformable DETR model)

deit — (DeiT model)

deta — (DETA model)

detr — (DETR model)

dinat — (DiNAT model)

dinov2 — (DINOv2 model)

distilbert — (DistilBERT model)

donut-swin — (DonutSwin model)

dpr — (DPR model)

dpt — (DPT model)

efficientformer — (EfficientFormer model)

efficientnet — (EfficientNet model)

electra — (ELECTRA model)

encodec — (EnCodec model)

encoder-decoder — (Encoder decoder model)

ernie — (ERNIE model)

ernie_m — (ErnieM model)

esm — (ESM model)

falcon — (Falcon model)

flaubert — (FlauBERT model)

flava — (FLAVA model)

fnet — (FNet model)

focalnet — (FocalNet model)

fsmt — (FairSeq Machine-Translation model)

funnel — (Funnel Transformer model)

git — (GIT model)

glpn — (GLPN model)

gpt-sw3 — (GPT-Sw3 model)

gpt2 — (OpenAI GPT-2 model)

gpt_bigcode — (GPTBigCode model)

gpt_neo — (GPT Neo model)

gpt_neox — (GPT NeoX model)

gpt_neox_japanese — (GPT NeoX Japanese model)

gptj — (GPT-J model)

gptsan-japanese — (GPTSAN-japanese model)

graphormer — (Graphormer model)

groupvit — (GroupViT model)

hubert — (Hubert model)

ibert — (I-BERT model)

idefics — (IDEFICS model)

imagegpt — (ImageGPT model)

informer — (Informer model)

instructblip — (InstructBLIP model)

jukebox — (Jukebox model)

layoutlm — (LayoutLM model)

layoutlmv2 — (LayoutLMv2 model)

layoutlmv3 — (LayoutLMv3 model)

led — (LED model)

levit — (LeViT model)

lilt — (LiLT model)

llama — (LLaMA model)

longformer — (Longformer model)

longt5 — (LongT5 model)

luke — (LUKE model)

lxmert — (LXMERT model)

m2m_100 — (M2M100 model)

marian — (Marian model)

markuplm — (MarkupLM model)

mask2former — (Mask2Former model)

maskformer — (MaskFormer model)

mbart — (mBART model)

mctct — (M-CTC-T model)

mega — (MEGA model)

megatron-bert — (Megatron-BERT model)

mgp-str — (MGP-STR model)

mistral — (Mistral model)

mobilebert — (MobileBERT model)

mobilenet_v1 — (MobileNetV1 model)

mobilenet_v2 — (MobileNetV2 model)

mobilevit — (MobileViT model)

mobilevitv2 — (MobileViTV2 model)

mpnet — (MPNet model)

mpt — (MPT model)

mra — (MRA model)

mt5 — (MT5 model)

musicgen — (MusicGen model)

mvp — (MVP model)

nat — (NAT model)

nezha — (Nezha model)

nllb-moe — (NLLB-MOE model)

nougat — (Nougat model)

nystromformer — (Nyströmformer model)

oneformer — (OneFormer model)

open-llama — (OpenLlama model)

openai-gpt — (OpenAI GPT model)

opt — (OPT model)

owlvit — (OWL-ViT model)

pegasus — (Pegasus model)

pegasus_x — (PEGASUS-X model)

perceiver — (Perceiver model)

persimmon — (Persimmon model)

pix2struct — (Pix2Struct model)

plbart — (PLBart model)

poolformer — (PoolFormer model)

pop2piano — (Pop2Piano model)

prophetnet — (ProphetNet model)

pvt — (PVT model)

qdqbert — (QDQBert model)

rag — (RAG model)

realm — (REALM model)

reformer — (Reformer model)

regnet — (RegNet model)

rembert — (RemBERT model)

resnet — (ResNet model)

retribert — (RetriBERT model)

roberta — (RoBERTa model)

roberta-prelayernorm — (RoBERTa-PreLayerNorm model)

roc_bert — (RoCBert model)

roformer — (RoFormer model)

rwkv — (RWKV model)

sam — (SAM model)

segformer — (SegFormer model)

sew — (SEW model)

sew-d — (SEW-D model)

speech-encoder-decoder — (Speech Encoder decoder model)

speech_to_text — (Speech2Text model)

speech_to_text_2 — (Speech2Text2 model)

speecht5 — (SpeechT5 model)

splinter — (Splinter model)

squeezebert — (SqueezeBERT model)

swiftformer — (SwiftFormer model)

swin — (Swin Transformer model)

swin2sr — (Swin2SR model)

swinv2 — (Swin Transformer V2 model)

switch_transformers — (SwitchTransformers model)

t5 — (T5 model)

table-transformer — (Table Transformer model)

tapas — (TAPAS model)

time_series_transformer — (Time Series Transformer model)

timesformer — (TimeSformer model)

trajectory_transformer — (Trajectory Transformer model)

transfo-xl — (Transformer-XL model)

trocr — (TrOCR model)

tvlt — (TVLT model)

umt5 — (UMT5 model)

unispeech — (UniSpeech model)

unispeech-sat — (UniSpeechSat model)

upernet — (UPerNet model)

van — (VAN model)

videomae — (VideoMAE model)

vilt — (ViLT model)

vision-encoder-decoder — (Vision Encoder decoder model)

vision-text-dual-encoder — (VisionTextDualEncoder model)

visual_bert — (VisualBERT model)

vit — (ViT model)

vit_hybrid — (ViT Hybrid model)

vit_mae — (ViTMAE model)

vit_msn — (ViTMSN model)

vitdet — (VitDet model)

vitmatte — (ViTMatte model)

vits — (VITS model)

vivit — (ViViT model)

wav2vec2 — (Wav2Vec2 model)

wav2vec2-conformer — (Wav2Vec2-Conformer model)

wavlm — (WavLM model)

whisper — (Whisper model)

xclip — (X-CLIP model)

xglm — (XGLM model)

xlm — (XLM model)

xlm-prophetnet — (XLM-ProphetNet model)

xlm-roberta — (XLM-RoBERTa model)

xlm-roberta-xl — (XLM-RoBERTa-XL model)

xlnet — (XLNet model)

xmod — (X-MOD model)

yolos — (YOLOS model)

yoso — (YOSO model)

config () — The config to register.

🌍
🌍
🌍
<source>
from_pretrained()
<source>
save_pretrained()
save_pretrained()
AlbertConfig
AlignConfig
AltCLIPConfig
ASTConfig
AutoformerConfig
BarkConfig
BartConfig
BeitConfig
BertConfig
BertGenerationConfig
BigBirdConfig
BigBirdPegasusConfig
BioGptConfig
BitConfig
BlenderbotConfig
BlenderbotSmallConfig
BlipConfig
Blip2Config
BloomConfig
BridgeTowerConfig
BrosConfig
CamembertConfig
CanineConfig
ChineseCLIPConfig
ClapConfig
CLIPConfig
CLIPSegConfig
LlamaConfig
CodeGenConfig
ConditionalDetrConfig
ConvBertConfig
ConvNextConfig
ConvNextV2Config
CpmAntConfig
CTRLConfig
CvtConfig
Data2VecAudioConfig
Data2VecTextConfig
Data2VecVisionConfig
DebertaConfig
DebertaV2Config
DecisionTransformerConfig
DeformableDetrConfig
DeiTConfig
DetaConfig
DetrConfig
DinatConfig
Dinov2Config
DistilBertConfig
DonutSwinConfig
DPRConfig
DPTConfig
EfficientFormerConfig
EfficientNetConfig
ElectraConfig
EncodecConfig
EncoderDecoderConfig
ErnieConfig
ErnieMConfig
EsmConfig
FalconConfig
FlaubertConfig
FlavaConfig
FNetConfig
FocalNetConfig
FSMTConfig
FunnelConfig
GitConfig
GLPNConfig
GPT2Config
GPT2Config
GPTBigCodeConfig
GPTNeoConfig
GPTNeoXConfig
GPTNeoXJapaneseConfig
GPTJConfig
GPTSanJapaneseConfig
GraphormerConfig
GroupViTConfig
HubertConfig
IBertConfig
IdeficsConfig
ImageGPTConfig
InformerConfig
InstructBlipConfig
JukeboxConfig
LayoutLMConfig
LayoutLMv2Config
LayoutLMv3Config
LEDConfig
LevitConfig
LiltConfig
LlamaConfig
LongformerConfig
LongT5Config
LukeConfig
LxmertConfig
M2M100Config
MarianConfig
MarkupLMConfig
Mask2FormerConfig
MaskFormerConfig
MBartConfig
MCTCTConfig
MegaConfig
MegatronBertConfig
MgpstrConfig
MistralConfig
MobileBertConfig
MobileNetV1Config
MobileNetV2Config
MobileViTConfig
MobileViTV2Config
MPNetConfig
MptConfig
MraConfig
MT5Config
MusicgenConfig
MvpConfig
NatConfig
NezhaConfig
NllbMoeConfig
VisionEncoderDecoderConfig
NystromformerConfig
OneFormerConfig
OpenLlamaConfig
OpenAIGPTConfig
OPTConfig
OwlViTConfig
PegasusConfig
PegasusXConfig
PerceiverConfig
PersimmonConfig
Pix2StructConfig
PLBartConfig
PoolFormerConfig
Pop2PianoConfig
ProphetNetConfig
PvtConfig
QDQBertConfig
RagConfig
RealmConfig
ReformerConfig
RegNetConfig
RemBertConfig
ResNetConfig
RetriBertConfig
RobertaConfig
RobertaPreLayerNormConfig
RoCBertConfig
RoFormerConfig
RwkvConfig
SamConfig
SegformerConfig
SEWConfig
SEWDConfig
SpeechEncoderDecoderConfig
Speech2TextConfig
Speech2Text2Config
SpeechT5Config
SplinterConfig
SqueezeBertConfig
SwiftFormerConfig
SwinConfig
Swin2SRConfig
Swinv2Config
SwitchTransformersConfig
T5Config
TableTransformerConfig
TapasConfig
TimeSeriesTransformerConfig
TimesformerConfig
TrajectoryTransformerConfig
TransfoXLConfig
TrOCRConfig
TvltConfig
UMT5Config
UniSpeechConfig
UniSpeechSatConfig
UperNetConfig
VanConfig
VideoMAEConfig
ViltConfig
VisionEncoderDecoderConfig
VisionTextDualEncoderConfig
VisualBertConfig
ViTConfig
ViTHybridConfig
ViTMAEConfig
ViTMSNConfig
VitDetConfig
VitMatteConfig
VitsConfig
VivitConfig
Wav2Vec2Config
Wav2Vec2ConformerConfig
WavLMConfig
WhisperConfig
XCLIPConfig
XGLMConfig
XLMConfig
XLMProphetNetConfig
XLMRobertaConfig
XLMRobertaXLConfig
XLNetConfig
XmodConfig
YolosConfig
YosoConfig
<source>
PretrainedConfig