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:

• aimv2 — Aimv2Config (AIMv2 model)
• aimv2_vision_model — Aimv2VisionConfig (Aimv2VisionModel model)
• albert — AlbertConfig (ALBERT model)
• align — AlignConfig (ALIGN model)
• altclip — AltCLIPConfig (AltCLIP model)
• apertus — ApertusConfig (Apertus model)
• arcee — ArceeConfig (Arcee model)
• aria — AriaConfig (Aria model)
• aria_text — AriaTextConfig (AriaText model)
• audio-spectrogram-transformer — ASTConfig (Audio Spectrogram Transformer model)
• autoformer — AutoformerConfig (Autoformer model)
• aya_vision — AyaVisionConfig (AyaVision model)
• bamba — BambaConfig (Bamba model)
• bark — BarkConfig (Bark model)
• bart — BartConfig (BART model)
• beit — BeitConfig (BEiT model)
• bert — BertConfig (BERT model)
• bert-generation — BertGenerationConfig (Bert Generation model)
• big_bird — BigBirdConfig (BigBird model)
• bigbird_pegasus — BigBirdPegasusConfig (BigBird-Pegasus model)
• biogpt — BioGptConfig (BioGpt model)
• bit — BitConfig (BiT model)
• bitnet — BitNetConfig (BitNet model)
• blenderbot — BlenderbotConfig (Blenderbot model)
• blenderbot-small — BlenderbotSmallConfig (BlenderbotSmall model)
• blip — BlipConfig (BLIP model)
• blip-2 — Blip2Config (BLIP-2 model)
• blip_2_qformer — Blip2QFormerConfig (BLIP-2 QFormer model)
• bloom — BloomConfig (BLOOM model)
• blt — BltConfig (Blt model)
• bridgetower — BridgeTowerConfig (BridgeTower model)
• bros — BrosConfig (BROS model)
• camembert — CamembertConfig (CamemBERT model)
• canine — CanineConfig (CANINE model)
• chameleon — ChameleonConfig (Chameleon model)
• chinese_clip — ChineseCLIPConfig (Chinese-CLIP model)
• chinese_clip_vision_model — ChineseCLIPVisionConfig (ChineseCLIPVisionModel model)
• clap — ClapConfig (CLAP model)
• clip — CLIPConfig (CLIP model)
• clip_text_model — CLIPTextConfig (CLIPTextModel model)
• clip_vision_model — CLIPVisionConfig (CLIPVisionModel model)
• clipseg — CLIPSegConfig (CLIPSeg model)
• clvp — ClvpConfig (CLVP model)
• code_llama — LlamaConfig (CodeLlama model)
• codegen — CodeGenConfig (CodeGen model)
• cohere — CohereConfig (Cohere model)
• cohere2 — Cohere2Config (Cohere2 model)
• cohere2_vision — Cohere2VisionConfig (Cohere2Vision model)
• colpali — ColPaliConfig (ColPali model)
• colqwen2 — ColQwen2Config (ColQwen2 model)
• conditional_detr — ConditionalDetrConfig (Conditional DETR model)
• convbert — ConvBertConfig (ConvBERT model)
• convnext — ConvNextConfig (ConvNeXT model)
• convnextv2 — ConvNextV2Config (ConvNeXTV2 model)
• cpmant — CpmAntConfig (CPM-Ant model)
• csm — CsmConfig (CSM model)
• ctrl — CTRLConfig (CTRL model)
• cvt — CvtConfig (CvT model)
• d_fine — DFineConfig (D-FINE model)
• dab-detr — DabDetrConfig (DAB-DETR model)
• dac — DacConfig (DAC model)
• data2vec-audio — Data2VecAudioConfig (Data2VecAudio model)
• data2vec-text — Data2VecTextConfig (Data2VecText model)
• data2vec-vision — Data2VecVisionConfig (Data2VecVision model)
• dbrx — DbrxConfig (DBRX model)
• deberta — DebertaConfig (DeBERTa model)
• deberta-v2 — DebertaV2Config (DeBERTa-v2 model)
• decision_transformer — DecisionTransformerConfig (Decision Transformer model)
• deepseek_v2 — DeepseekV2Config (DeepSeek-V2 model)
• deepseek_v3 — DeepseekV3Config (DeepSeek-V3 model)
• deepseek_vl — DeepseekVLConfig (DeepseekVL model)
• deepseek_vl_hybrid — DeepseekVLHybridConfig (DeepseekVLHybrid model)
• deformable_detr — DeformableDetrConfig (Deformable DETR model)
• deit — DeiTConfig (DeiT model)
• depth_anything — DepthAnythingConfig (Depth Anything model)
• depth_pro — DepthProConfig (DepthPro model)
• deta — DetaConfig (DETA model)
• detr — DetrConfig (DETR model)
• dia — DiaConfig (Dia model)
• diffllama — DiffLlamaConfig (DiffLlama model)
• dinat — DinatConfig (DiNAT model)
• dinov2 — Dinov2Config (DINOv2 model)
• dinov2_with_registers — Dinov2WithRegistersConfig (DINOv2 with Registers model)
• dinov3_convnext — DINOv3ConvNextConfig (DINOv3 ConvNext model)
• dinov3_vit — DINOv3ViTConfig (DINOv3 ViT model)
• distilbert — DistilBertConfig (DistilBERT model)
• doge — DogeConfig (Doge model)
• donut-swin — DonutSwinConfig (DonutSwin model)
• dots1 — Dots1Config (dots1 model)
• dpr — DPRConfig (DPR model)
• dpt — DPTConfig (DPT model)
• edgetam — EdgeTamConfig (EdgeTAM model)
• edgetam_video — EdgeTamVideoConfig (EdgeTamVideo model)
• edgetam_vision_model — EdgeTamVisionConfig (EdgeTamVisionModel model)
• efficientformer — EfficientFormerConfig (EfficientFormer model)
• efficientloftr — EfficientLoFTRConfig (EfficientLoFTR model)
• efficientnet — EfficientNetConfig (EfficientNet model)
• electra — ElectraConfig (ELECTRA model)
• emu3 — Emu3Config (Emu3 model)
• encodec — EncodecConfig (EnCodec model)
• encoder-decoder — EncoderDecoderConfig (Encoder decoder model)
• eomt — EomtConfig (EoMT model)
• ernie — ErnieConfig (ERNIE model)
• ernie4_5 — Ernie4_5Config (Ernie4_5 model)
• ernie4_5_moe — Ernie4_5_MoeConfig (Ernie4_5_MoE model)
• ernie_m — ErnieMConfig (ErnieM model)
• esm — EsmConfig (ESM model)
• evolla — EvollaConfig (Evolla model)
• exaone4 — Exaone4Config (EXAONE-4.0 model)
• falcon — FalconConfig (Falcon model)
• falcon_h1 — FalconH1Config (FalconH1 model)
• falcon_mamba — FalconMambaConfig (FalconMamba model)
• fastspeech2_conformer — FastSpeech2ConformerConfig (FastSpeech2Conformer model)
• fastspeech2_conformer_with_hifigan — FastSpeech2ConformerWithHifiGanConfig (FastSpeech2ConformerWithHifiGan model)
• flaubert — FlaubertConfig (FlauBERT model)
• flava — FlavaConfig (FLAVA model)
• flex_olmo — FlexOlmoConfig (FlexOlmo model)
• florence2 — Florence2Config (Florence2 model)
• fnet — FNetConfig (FNet model)
• focalnet — FocalNetConfig (FocalNet model)
• fsmt — FSMTConfig (FairSeq Machine-Translation model)
• funnel — FunnelConfig (Funnel Transformer model)
• fuyu — FuyuConfig (Fuyu model)
• gemma — GemmaConfig (Gemma model)
• gemma2 — Gemma2Config (Gemma2 model)
• gemma3 — Gemma3Config (Gemma3ForConditionalGeneration model)
• gemma3_text — Gemma3TextConfig (Gemma3ForCausalLM model)
• gemma3n — Gemma3nConfig (Gemma3nForConditionalGeneration model)
• gemma3n_audio — Gemma3nAudioConfig (Gemma3nAudioEncoder model)
• gemma3n_text — Gemma3nTextConfig (Gemma3nForCausalLM model)
• gemma3n_vision — Gemma3nVisionConfig (TimmWrapperModel model)
• git — GitConfig (GIT model)
• glm — GlmConfig (GLM model)
• glm4 — Glm4Config (GLM4 model)
• glm4_moe — Glm4MoeConfig (Glm4MoE model)
• glm4v — Glm4vConfig (GLM4V model)
• glm4v_moe — Glm4vMoeConfig (GLM4VMOE model)
• glm4v_moe_text — Glm4vMoeTextConfig (GLM4VMOE model)
• glm4v_text — Glm4vTextConfig (GLM4V model)
• glpn — GLPNConfig (GLPN model)
• got_ocr2 — GotOcr2Config (GOT-OCR2 model)
• gpt-sw3 — GPT2Config (GPT-Sw3 model)
• gpt2 — GPT2Config (OpenAI GPT-2 model)
• gpt_bigcode — GPTBigCodeConfig (GPTBigCode model)
• gpt_neo — GPTNeoConfig (GPT Neo model)
• gpt_neox — GPTNeoXConfig (GPT NeoX model)
• gpt_neox_japanese — GPTNeoXJapaneseConfig (GPT NeoX Japanese model)
• gpt_oss — GptOssConfig (GptOss model)
• gptj — GPTJConfig (GPT-J model)
• gptsan-japanese — GPTSanJapaneseConfig (GPTSAN-japanese model)
• granite — GraniteConfig (Granite model)
• granite_speech — GraniteSpeechConfig (GraniteSpeech model)
• granitemoe — GraniteMoeConfig (GraniteMoeMoe model)
• granitemoehybrid — GraniteMoeHybridConfig (GraniteMoeHybrid model)
• granitemoeshared — GraniteMoeSharedConfig (GraniteMoeSharedMoe model)
• granitevision — LlavaNextConfig (LLaVA-NeXT model)
• graphormer — GraphormerConfig (Graphormer model)
• grounding-dino — GroundingDinoConfig (Grounding DINO model)
• groupvit — GroupViTConfig (GroupViT model)
• helium — HeliumConfig (Helium model)
• hgnet_v2 — HGNetV2Config (HGNet-V2 model)
• hiera — HieraConfig (Hiera model)
• hubert — HubertConfig (Hubert model)
• hunyuan_v1_dense — HunYuanDenseV1Config (HunYuanDenseV1 model)
• hunyuan_v1_moe — HunYuanMoEV1Config (HunYuanMoeV1 model)
• ibert — IBertConfig (I-BERT model)
• idefics — IdeficsConfig (IDEFICS model)
• idefics2 — Idefics2Config (Idefics2 model)
• idefics3 — Idefics3Config (Idefics3 model)
• idefics3_vision — Idefics3VisionConfig (Idefics3VisionTransformer model)
• ijepa — IJepaConfig (I-JEPA model)
• imagegpt — ImageGPTConfig (ImageGPT model)
• informer — InformerConfig (Informer model)
• instructblip — InstructBlipConfig (InstructBLIP model)
• instructblipvideo — InstructBlipVideoConfig (InstructBlipVideo model)
• internvl — InternVLConfig (InternVL model)
• internvl_vision — InternVLVisionConfig (InternVLVision model)
• jamba — JambaConfig (Jamba model)
• janus — JanusConfig (Janus model)
• jetmoe — JetMoeConfig (JetMoe model)
• jukebox — JukeboxConfig (Jukebox model)
• kosmos-2 — Kosmos2Config (KOSMOS-2 model)
• kosmos-2.5 — Kosmos2_5Config (KOSMOS-2.5 model)
• kyutai_speech_to_text — KyutaiSpeechToTextConfig (KyutaiSpeechToText model)
• layoutlm — LayoutLMConfig (LayoutLM model)
• layoutlmv2 — LayoutLMv2Config (LayoutLMv2 model)
• layoutlmv3 — LayoutLMv3Config (LayoutLMv3 model)
• led — LEDConfig (LED model)
• levit — LevitConfig (LeViT model)
• lfm2 — Lfm2Config (Lfm2 model)
• lfm2_vl — Lfm2VlConfig (Lfm2Vl model)
• lightglue — LightGlueConfig (LightGlue model)
• lilt — LiltConfig (LiLT model)
• llama — LlamaConfig (LLaMA model)
• llama4 — Llama4Config (Llama4 model)
• llama4_text — Llama4TextConfig (Llama4ForCausalLM model)
• llava — LlavaConfig (LLaVa model)
• llava_next — LlavaNextConfig (LLaVA-NeXT model)
• llava_next_video — LlavaNextVideoConfig (LLaVa-NeXT-Video model)
• llava_onevision — LlavaOnevisionConfig (LLaVA-Onevision model)
• longcat_flash — LongcatFlashConfig (LongCatFlash model)
• longformer — LongformerConfig (Longformer model)
• longt5 — LongT5Config (LongT5 model)
• luke — LukeConfig (LUKE model)
• lxmert — LxmertConfig (LXMERT model)
• m2m_100 — M2M100Config (M2M100 model)
• mamba — MambaConfig (Mamba model)
• mamba2 — Mamba2Config (mamba2 model)
• marian — MarianConfig (Marian model)
• markuplm — MarkupLMConfig (MarkupLM model)
• mask2former — Mask2FormerConfig (Mask2Former model)
• maskformer — MaskFormerConfig (MaskFormer model)
• maskformer-swin — MaskFormerSwinConfig (MaskFormerSwin model)
• mbart — MBartConfig (mBART model)
• mctct — MCTCTConfig (M-CTC-T model)
• mega — MegaConfig (MEGA model)
• megatron-bert — MegatronBertConfig (Megatron-BERT model)
• metaclip_2 — MetaClip2Config (MetaCLIP 2 model)
• mgp-str — MgpstrConfig (MGP-STR model)
• mimi — MimiConfig (Mimi model)
• minimax — MiniMaxConfig (MiniMax model)
• ministral — MinistralConfig (Ministral model)
• mistral — MistralConfig (Mistral model)
• mistral3 — Mistral3Config (Mistral3 model)
• mixtral — MixtralConfig (Mixtral model)
• mlcd — MLCDVisionConfig (MLCD model)
• mllama — MllamaConfig (Mllama model)
• mm-grounding-dino — MMGroundingDinoConfig (MM Grounding DINO model)
• mobilebert — MobileBertConfig (MobileBERT model)
• mobilenet_v1 — MobileNetV1Config (MobileNetV1 model)
• mobilenet_v2 — MobileNetV2Config (MobileNetV2 model)
• mobilevit — MobileViTConfig (MobileViT model)
• mobilevitv2 — MobileViTV2Config (MobileViTV2 model)
• modernbert — ModernBertConfig (ModernBERT model)
• modernbert-decoder — ModernBertDecoderConfig (ModernBertDecoder model)
• moonshine — MoonshineConfig (Moonshine model)
• moshi — MoshiConfig (Moshi model)
• mpnet — MPNetConfig (MPNet model)
• mpt — MptConfig (MPT model)
• mra — MraConfig (MRA model)
• mt5 — MT5Config (MT5 model)
• musicgen — MusicgenConfig (MusicGen model)
• musicgen_melody — MusicgenMelodyConfig (MusicGen Melody model)
• mvp — MvpConfig (MVP model)
• nat — NatConfig (NAT model)
• nemotron — NemotronConfig (Nemotron model)
• nezha — NezhaConfig (Nezha model)
• nllb-moe — NllbMoeConfig (NLLB-MOE model)
• nougat — VisionEncoderDecoderConfig (Nougat model)
• nystromformer — NystromformerConfig (Nyströmformer model)
• olmo — OlmoConfig (OLMo model)
• olmo2 — Olmo2Config (OLMo2 model)
• olmo3 — Olmo3Config (Olmo3 model)
• olmoe — OlmoeConfig (OLMoE model)
• omdet-turbo — OmDetTurboConfig (OmDet-Turbo model)
• oneformer — OneFormerConfig (OneFormer model)
• open-llama — OpenLlamaConfig (OpenLlama model)
• openai-gpt — OpenAIGPTConfig (OpenAI GPT model)
• opt — OPTConfig (OPT model)
• ovis2 — Ovis2Config (Ovis2 model)
• owlv2 — Owlv2Config (OWLv2 model)
• owlvit — OwlViTConfig (OWL-ViT model)
• paligemma — PaliGemmaConfig (PaliGemma model)
• parakeet_ctc — ParakeetCTCConfig (Parakeet model)
• parakeet_encoder — ParakeetEncoderConfig (ParakeetEncoder model)
• patchtsmixer — PatchTSMixerConfig (PatchTSMixer model)
• patchtst — PatchTSTConfig (PatchTST model)
• pegasus — PegasusConfig (Pegasus model)
• pegasus_x — PegasusXConfig (PEGASUS-X model)
• perceiver — PerceiverConfig (Perceiver model)
• perception_encoder — TimmWrapperConfig (PerceptionEncoder model)
• perception_lm — PerceptionLMConfig (PerceptionLM model)
• persimmon — PersimmonConfig (Persimmon model)
• phi — PhiConfig (Phi model)
• phi3 — Phi3Config (Phi3 model)
• phi4_multimodal — Phi4MultimodalConfig (Phi4Multimodal model)
• phimoe — PhimoeConfig (Phimoe model)
• pix2struct — Pix2StructConfig (Pix2Struct model)
• pixtral — PixtralVisionConfig (Pixtral model)
• plbart — PLBartConfig (PLBart model)
• poolformer — PoolFormerConfig (PoolFormer model)
• pop2piano — Pop2PianoConfig (Pop2Piano model)
• prompt_depth_anything — PromptDepthAnythingConfig (PromptDepthAnything model)
• prophetnet — ProphetNetConfig (ProphetNet model)
• pvt — PvtConfig (PVT model)
• pvt_v2 — PvtV2Config (PVTv2 model)
• qdqbert — QDQBertConfig (QDQBert model)
• qwen2 — Qwen2Config (Qwen2 model)
• qwen2_5_omni — Qwen2_5OmniConfig (Qwen2_5Omni model)
• qwen2_5_vl — Qwen2_5_VLConfig (Qwen2_5_VL model)
• qwen2_5_vl_text — Qwen2_5_VLTextConfig (Qwen2_5_VL model)
• qwen2_audio — Qwen2AudioConfig (Qwen2Audio model)
• qwen2_audio_encoder — Qwen2AudioEncoderConfig (Qwen2AudioEncoder model)
• qwen2_moe — Qwen2MoeConfig (Qwen2MoE model)
• qwen2_vl — Qwen2VLConfig (Qwen2VL model)
• qwen2_vl_text — Qwen2VLTextConfig (Qwen2VL model)
• qwen3 — Qwen3Config (Qwen3 model)
• qwen3_moe — Qwen3MoeConfig (Qwen3MoE model)
• qwen3_next — Qwen3NextConfig (Qwen3Next model)
• qwen3_omni_moe — Qwen3OmniMoeConfig (Qwen3OmniMoE model)
• qwen3_vl — Qwen3VLConfig (Qwen3VL model)
• qwen3_vl_moe — Qwen3VLMoeConfig (Qwen3VLMoe model)
• qwen3_vl_moe_text — Qwen3VLMoeTextConfig (Qwen3VLMoe model)
• qwen3_vl_text — Qwen3VLTextConfig (Qwen3VL model)
• rag — RagConfig (RAG model)
• realm — RealmConfig (REALM model)
• recurrent_gemma — RecurrentGemmaConfig (RecurrentGemma model)
• reformer — ReformerConfig (Reformer model)
• regnet — RegNetConfig (RegNet model)
• rembert — RemBertConfig (RemBERT model)
• resnet — ResNetConfig (ResNet model)
• retribert — RetriBertConfig (RetriBERT model)
• roberta — RobertaConfig (RoBERTa model)
• roberta-prelayernorm — RobertaPreLayerNormConfig (RoBERTa-PreLayerNorm model)
• roc_bert — RoCBertConfig (RoCBert model)
• roformer — RoFormerConfig (RoFormer model)
• rt_detr — RTDetrConfig (RT-DETR model)
• rt_detr_resnet — RTDetrResNetConfig (RT-DETR-ResNet model)
• rt_detr_v2 — RTDetrV2Config (RT-DETRv2 model)
• rwkv — RwkvConfig (RWKV model)
• sam — SamConfig (SAM model)
• sam2 — Sam2Config (SAM2 model)
• sam2_hiera_det_model — Sam2HieraDetConfig (Sam2HieraDetModel model)
• sam2_video — Sam2VideoConfig (Sam2VideoModel model)
• sam2_vision_model — Sam2VisionConfig (Sam2VisionModel model)
• sam_hq — SamHQConfig (SAM-HQ model)
• sam_hq_vision_model — SamHQVisionConfig (SamHQVisionModel model)
• sam_vision_model — SamVisionConfig (SamVisionModel model)
• seamless_m4t — SeamlessM4TConfig (SeamlessM4T model)
• seamless_m4t_v2 — SeamlessM4Tv2Config (SeamlessM4Tv2 model)
• seed_oss — SeedOssConfig (SeedOss model)
• segformer — SegformerConfig (SegFormer model)
• seggpt — SegGptConfig (SegGPT model)
• sew — SEWConfig (SEW model)
• sew-d — SEWDConfig (SEW-D model)
• shieldgemma2 — ShieldGemma2Config (Shieldgemma2 model)
• siglip — SiglipConfig (SigLIP model)
• siglip2 — Siglip2Config (SigLIP2 model)
• siglip2_vision_model — Siglip2VisionConfig (Siglip2VisionModel model)
• siglip_vision_model — SiglipVisionConfig (SiglipVisionModel model)
• smollm3 — SmolLM3Config (SmolLM3 model)
• smolvlm — SmolVLMConfig (SmolVLM model)
• smolvlm_vision — SmolVLMVisionConfig (SmolVLMVisionTransformer model)
• speech-encoder-decoder — SpeechEncoderDecoderConfig (Speech Encoder decoder model)
• speech_to_text — Speech2TextConfig (Speech2Text model)
• speech_to_text_2 — Speech2Text2Config (Speech2Text2 model)
• speecht5 — SpeechT5Config (SpeechT5 model)
• splinter — SplinterConfig (Splinter model)
• squeezebert — SqueezeBertConfig (SqueezeBERT model)
• stablelm — StableLmConfig (StableLm model)
• starcoder2 — Starcoder2Config (Starcoder2 model)
• superglue — SuperGlueConfig (SuperGlue model)
• superpoint — SuperPointConfig (SuperPoint model)
• swiftformer — SwiftFormerConfig (SwiftFormer model)
• swin — SwinConfig (Swin Transformer model)
• swin2sr — Swin2SRConfig (Swin2SR model)
• swinv2 — Swinv2Config (Swin Transformer V2 model)
• switch_transformers — SwitchTransformersConfig (SwitchTransformers model)
• t5 — T5Config (T5 model)
• t5gemma — T5GemmaConfig (T5Gemma model)
• table-transformer — TableTransformerConfig (Table Transformer model)
• tapas — TapasConfig (TAPAS model)
• textnet — TextNetConfig (TextNet model)
• time_series_transformer — TimeSeriesTransformerConfig (Time Series Transformer model)
• timesfm — TimesFmConfig (TimesFm model)
• timesformer — TimesformerConfig (TimeSformer model)
• timm_backbone — TimmBackboneConfig (TimmBackbone model)
• timm_wrapper — TimmWrapperConfig (TimmWrapperModel model)
• trajectory_transformer — TrajectoryTransformerConfig (Trajectory Transformer model)
• transfo-xl — TransfoXLConfig (Transformer-XL model)
• trocr — TrOCRConfig (TrOCR model)
• tvlt — TvltConfig (TVLT model)
• tvp — TvpConfig (TVP model)
• udop — UdopConfig (UDOP model)
• umt5 — UMT5Config (UMT5 model)
• unispeech — UniSpeechConfig (UniSpeech model)
• unispeech-sat — UniSpeechSatConfig (UniSpeechSat model)
• univnet — UnivNetConfig (UnivNet model)
• upernet — UperNetConfig (UPerNet model)
• van — VanConfig (VAN model)
• vaultgemma — VaultGemmaConfig (VaultGemma model)
• video_llava — VideoLlavaConfig (VideoLlava model)
• videomae — VideoMAEConfig (VideoMAE model)
• vilt — ViltConfig (ViLT model)
• vipllava — VipLlavaConfig (VipLlava model)
• vision-encoder-decoder — VisionEncoderDecoderConfig (Vision Encoder decoder model)
• vision-text-dual-encoder — VisionTextDualEncoderConfig (VisionTextDualEncoder model)
• visual_bert — VisualBertConfig (VisualBERT model)
• vit — ViTConfig (ViT model)
• vit_hybrid — ViTHybridConfig (ViT Hybrid model)
• vit_mae — ViTMAEConfig (ViTMAE model)
• vit_msn — ViTMSNConfig (ViTMSN model)
• vitdet — VitDetConfig (VitDet model)
• vitmatte — VitMatteConfig (ViTMatte model)
• vitpose — VitPoseConfig (ViTPose model)
• vitpose_backbone — VitPoseBackboneConfig (ViTPoseBackbone model)
• vits — VitsConfig (VITS model)
• vivit — VivitConfig (ViViT model)
• vjepa2 — VJEPA2Config (VJEPA2Model model)
• voxtral — VoxtralConfig (Voxtral model)
• voxtral_encoder — VoxtralEncoderConfig (Voxtral Encoder model)
• wav2vec2 — Wav2Vec2Config (Wav2Vec2 model)
• wav2vec2-bert — Wav2Vec2BertConfig (Wav2Vec2-BERT model)
• wav2vec2-conformer — Wav2Vec2ConformerConfig (Wav2Vec2-Conformer model)
• wavlm — WavLMConfig (WavLM model)
• whisper — WhisperConfig (Whisper model)
• xclip — XCLIPConfig (X-CLIP model)
• xcodec — XcodecConfig (X-CODEC model)
• xglm — XGLMConfig (XGLM model)
• xlm — XLMConfig (XLM model)
• xlm-prophetnet — XLMProphetNetConfig (XLM-ProphetNet model)
• xlm-roberta — XLMRobertaConfig (XLM-RoBERTa model)
• xlm-roberta-xl — XLMRobertaXLConfig (XLM-RoBERTa-XL model)
• xlnet — XLNetConfig (XLNet model)
• xlstm — xLSTMConfig (xLSTM model)
• xmod — XmodConfig (X-MOD model)
• yolos — YolosConfig (YOLOS model)
• yoso — YosoConfig (YOSO model)
• zamba — ZambaConfig (Zamba model)
• zamba2 — Zamba2Config (Zamba2 model)
• zoedepth — ZoeDepthConfig (ZoeDepth model)

>>> from transformers import AutoConfig

>>> # Download configuration from huggingface.co and cache.
>>> config = AutoConfig.from_pretrained("google-bert/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("google-bert/bert-base-uncased", output_attentions=True, foo=False)
>>> config.output_attentions
True

>>> config, unused_kwargs = AutoConfig.from_pretrained(
...     "google-bert/bert-base-uncased", output_attentions=True, foo=False, return_unused_kwargs=True
... )
>>> config.output_attentions
True

>>> unused_kwargs
{'foo': False}

Register a new configuration for this class.

Instantiate one of the tokenizer classes of the library from a pretrained model vocabulary.

The tokenizer class to instantiate is selected based on the model_type property of the config object (either passed as an argument or loaded from pretrained_model_name_or_path if possible), or when it’s missing, by falling back to using pattern matching on pretrained_model_name_or_path:

• aimv2 — CLIPTokenizer or CLIPTokenizerFast (AIMv2 model)
• albert — AlbertTokenizer or AlbertTokenizerFast (ALBERT model)
• align — BertTokenizer or BertTokenizerFast (ALIGN model)
• arcee — LlamaTokenizer or LlamaTokenizerFast (Arcee model)
• aria — LlamaTokenizer or LlamaTokenizerFast (Aria model)
• aya_vision — CohereTokenizerFast (AyaVision model)
• bark — BertTokenizer or BertTokenizerFast (Bark model)
• bart — BartTokenizer or BartTokenizerFast (BART model)
• barthez — BarthezTokenizer or BarthezTokenizerFast (BARThez model)
• bartpho — BartphoTokenizer (BARTpho model)
• bert — BertTokenizer or BertTokenizerFast (BERT model)
• bert-generation — BertGenerationTokenizer (Bert Generation model)
• bert-japanese — BertJapaneseTokenizer (BertJapanese model)
• bertweet — BertweetTokenizer (BERTweet model)
• big_bird — BigBirdTokenizer or BigBirdTokenizerFast (BigBird model)
• bigbird_pegasus — PegasusTokenizer or PegasusTokenizerFast (BigBird-Pegasus model)
• biogpt — BioGptTokenizer (BioGpt model)
• bitnet — PreTrainedTokenizerFast (BitNet model)
• blenderbot — BlenderbotTokenizer or BlenderbotTokenizerFast (Blenderbot model)
• blenderbot-small — BlenderbotSmallTokenizer (BlenderbotSmall model)
• blip — BertTokenizer or BertTokenizerFast (BLIP model)
• blip-2 — GPT2Tokenizer or GPT2TokenizerFast (BLIP-2 model)
• bloom — BloomTokenizerFast (BLOOM model)
• blt — PreTrainedTokenizerFast (Blt model)
• bridgetower — RobertaTokenizer or RobertaTokenizerFast (BridgeTower model)
• bros — BertTokenizer or BertTokenizerFast (BROS model)
• byt5 — ByT5Tokenizer (ByT5 model)
• camembert — CamembertTokenizer or CamembertTokenizerFast (CamemBERT model)
• canine — CanineTokenizer (CANINE model)
• chameleon — LlamaTokenizer or LlamaTokenizerFast (Chameleon model)
• chinese_clip — BertTokenizer or BertTokenizerFast (Chinese-CLIP model)
• clap — RobertaTokenizer or RobertaTokenizerFast (CLAP model)
• clip — CLIPTokenizer or CLIPTokenizerFast (CLIP model)
• clipseg — CLIPTokenizer or CLIPTokenizerFast (CLIPSeg model)
• clvp — ClvpTokenizer (CLVP model)
• code_llama — CodeLlamaTokenizer or CodeLlamaTokenizerFast (CodeLlama model)
• codegen — CodeGenTokenizer or CodeGenTokenizerFast (CodeGen model)
• cohere — CohereTokenizerFast (Cohere model)
• cohere2 — CohereTokenizerFast (Cohere2 model)
• colpali — LlamaTokenizer or LlamaTokenizerFast (ColPali model)
• colqwen2 — Qwen2Tokenizer or Qwen2TokenizerFast (ColQwen2 model)
• convbert — ConvBertTokenizer or ConvBertTokenizerFast (ConvBERT model)
• cpm — CpmTokenizer or CpmTokenizerFast (CPM model)
• cpmant — CpmAntTokenizer (CPM-Ant model)
• csm — PreTrainedTokenizerFast (CSM model)
• ctrl — CTRLTokenizer (CTRL model)
• data2vec-audio — Wav2Vec2CTCTokenizer (Data2VecAudio model)
• data2vec-text — RobertaTokenizer or RobertaTokenizerFast (Data2VecText model)
• dbrx — GPT2Tokenizer or GPT2TokenizerFast (DBRX model)
• deberta — DebertaTokenizer or DebertaTokenizerFast (DeBERTa model)
• deberta-v2 — DebertaV2Tokenizer or DebertaV2TokenizerFast (DeBERTa-v2 model)
• deepseek_v2 — LlamaTokenizer or LlamaTokenizerFast (DeepSeek-V2 model)
• deepseek_v3 — LlamaTokenizer or LlamaTokenizerFast (DeepSeek-V3 model)
• deepseek_vl — LlamaTokenizer or LlamaTokenizerFast (DeepseekVL model)
• deepseek_vl_hybrid — LlamaTokenizer or LlamaTokenizerFast (DeepseekVLHybrid model)
• dia — DiaTokenizer (Dia model)
• diffllama — LlamaTokenizer or LlamaTokenizerFast (DiffLlama model)
• distilbert — DistilBertTokenizer or DistilBertTokenizerFast (DistilBERT model)
• dpr — DPRQuestionEncoderTokenizer or DPRQuestionEncoderTokenizerFast (DPR model)
• electra — ElectraTokenizer or ElectraTokenizerFast (ELECTRA model)
• emu3 — GPT2Tokenizer or GPT2TokenizerFast (Emu3 model)
• ernie — BertTokenizer or BertTokenizerFast (ERNIE model)
• ernie4_5 — LlamaTokenizerFast (Ernie4_5 model)
• ernie4_5_moe — LlamaTokenizerFast (Ernie4_5_MoE model)
• ernie_m — ErnieMTokenizer (ErnieM model)
• esm — EsmTokenizer (ESM model)
• exaone4 — GPT2Tokenizer or GPT2TokenizerFast (EXAONE-4.0 model)
• falcon — PreTrainedTokenizerFast (Falcon model)
• falcon_mamba — GPTNeoXTokenizerFast (FalconMamba model)
• fastspeech2_conformer — (FastSpeech2Conformer model)
• flaubert — FlaubertTokenizer (FlauBERT model)
• flex_olmo — GPT2TokenizerFast (FlexOlmo model)
• fnet — FNetTokenizer or FNetTokenizerFast (FNet model)
• fsmt — FSMTTokenizer (FairSeq Machine-Translation model)
• funnel — FunnelTokenizer or FunnelTokenizerFast (Funnel Transformer model)
• gemma — GemmaTokenizer or GemmaTokenizerFast (Gemma model)
• gemma2 — GemmaTokenizer or GemmaTokenizerFast (Gemma2 model)
• gemma3 — GemmaTokenizer or GemmaTokenizerFast (Gemma3ForConditionalGeneration model)
• gemma3_text — GemmaTokenizer or GemmaTokenizerFast (Gemma3ForCausalLM model)
• gemma3n — GemmaTokenizer or GemmaTokenizerFast (Gemma3nForConditionalGeneration model)
• gemma3n_text — GemmaTokenizer or GemmaTokenizerFast (Gemma3nForCausalLM model)
• git — BertTokenizer or BertTokenizerFast (GIT model)
• glm — PreTrainedTokenizerFast (GLM model)
• glm4 — PreTrainedTokenizerFast (GLM4 model)
• glm4_moe — PreTrainedTokenizerFast (Glm4MoE model)
• glm4v — PreTrainedTokenizerFast (GLM4V model)
• glm4v_moe — PreTrainedTokenizerFast (GLM4VMOE model)
• gpt-sw3 — GPTSw3Tokenizer (GPT-Sw3 model)
• gpt2 — GPT2Tokenizer or GPT2TokenizerFast (OpenAI GPT-2 model)
• gpt_bigcode — GPT2Tokenizer or GPT2TokenizerFast (GPTBigCode model)
• gpt_neo — GPT2Tokenizer or GPT2TokenizerFast (GPT Neo model)
• gpt_neox — GPTNeoXTokenizerFast (GPT NeoX model)
• gpt_neox_japanese — GPTNeoXJapaneseTokenizer (GPT NeoX Japanese model)
• gpt_oss — PreTrainedTokenizerFast (GptOss model)
• gptj — GPT2Tokenizer or GPT2TokenizerFast (GPT-J model)
• gptsan-japanese — GPTSanJapaneseTokenizer (GPTSAN-japanese model)
• granite — GPT2Tokenizer (Granite model)
• granitemoe — GPT2Tokenizer (GraniteMoeMoe model)
• granitemoehybrid — GPT2Tokenizer (GraniteMoeHybrid model)
• granitemoeshared — GPT2Tokenizer (GraniteMoeSharedMoe model)
• grounding-dino — BertTokenizer or BertTokenizerFast (Grounding DINO model)
• groupvit — CLIPTokenizer or CLIPTokenizerFast (GroupViT model)
• helium — PreTrainedTokenizerFast (Helium model)
• herbert — HerbertTokenizer or HerbertTokenizerFast (HerBERT model)
• hubert — Wav2Vec2CTCTokenizer (Hubert model)
• ibert — RobertaTokenizer or RobertaTokenizerFast (I-BERT model)
• idefics — LlamaTokenizerFast (IDEFICS model)
• idefics2 — LlamaTokenizer or LlamaTokenizerFast (Idefics2 model)
• idefics3 — LlamaTokenizer or LlamaTokenizerFast (Idefics3 model)
• instructblip — GPT2Tokenizer or GPT2TokenizerFast (InstructBLIP model)
• instructblipvideo — GPT2Tokenizer or GPT2TokenizerFast (InstructBlipVideo model)
• internvl — Qwen2Tokenizer or Qwen2TokenizerFast (InternVL model)
• jamba — LlamaTokenizer or LlamaTokenizerFast (Jamba model)
• janus — LlamaTokenizerFast (Janus model)
• jetmoe — LlamaTokenizer or LlamaTokenizerFast (JetMoe model)
• jukebox — JukeboxTokenizer (Jukebox model)
• kosmos-2 — XLMRobertaTokenizer or XLMRobertaTokenizerFast (KOSMOS-2 model)
• kosmos-2.5 — PreTrainedTokenizerFast (KOSMOS-2.5 model)
• layoutlm — LayoutLMTokenizer or LayoutLMTokenizerFast (LayoutLM model)
• layoutlmv2 — LayoutLMv2Tokenizer or LayoutLMv2TokenizerFast (LayoutLMv2 model)
• layoutlmv3 — LayoutLMv3Tokenizer or LayoutLMv3TokenizerFast (LayoutLMv3 model)
• layoutxlm — LayoutXLMTokenizer or LayoutXLMTokenizerFast (LayoutXLM model)
• led — LEDTokenizer or LEDTokenizerFast (LED model)
• lilt — LayoutLMv3Tokenizer or LayoutLMv3TokenizerFast (LiLT model)
• llama — LlamaTokenizer or LlamaTokenizerFast (LLaMA model)
• llama4 — LlamaTokenizer or LlamaTokenizerFast (Llama4 model)
• llama4_text — LlamaTokenizer or LlamaTokenizerFast (Llama4ForCausalLM model)
• llava — LlamaTokenizer or LlamaTokenizerFast (LLaVa model)
• llava_next — LlamaTokenizer or LlamaTokenizerFast (LLaVA-NeXT model)
• llava_next_video — LlamaTokenizer or LlamaTokenizerFast (LLaVa-NeXT-Video model)
• llava_onevision — LlamaTokenizer or LlamaTokenizerFast (LLaVA-Onevision model)
• longformer — LongformerTokenizer or LongformerTokenizerFast (Longformer model)
• longt5 — T5Tokenizer or T5TokenizerFast (LongT5 model)
• luke — LukeTokenizer (LUKE model)
• lxmert — LxmertTokenizer or LxmertTokenizerFast (LXMERT model)
• m2m_100 — M2M100Tokenizer (M2M100 model)
• mamba — GPTNeoXTokenizerFast (Mamba model)
• mamba2 — GPTNeoXTokenizerFast (mamba2 model)
• marian — MarianTokenizer (Marian model)
• mbart — MBartTokenizer or MBartTokenizerFast (mBART model)
• mbart50 — MBart50Tokenizer or MBart50TokenizerFast (mBART-50 model)
• mega — RobertaTokenizer or RobertaTokenizerFast (MEGA model)
• megatron-bert — BertTokenizer or BertTokenizerFast (Megatron-BERT model)
• metaclip_2 — XLMRobertaTokenizer or XLMRobertaTokenizerFast (MetaCLIP 2 model)
• mgp-str — MgpstrTokenizer (MGP-STR model)
• minimax — GPT2Tokenizer or GPT2TokenizerFast (MiniMax model)
• mistral — MistralCommonTokenizer (Mistral model)
• mixtral — MistralCommonTokenizer (Mixtral model)
• mllama — LlamaTokenizer or LlamaTokenizerFast (Mllama model)
• mluke — MLukeTokenizer (mLUKE model)
• mm-grounding-dino — BertTokenizer or BertTokenizerFast (MM Grounding DINO model)
• mobilebert — MobileBertTokenizer or MobileBertTokenizerFast (MobileBERT model)
• modernbert — PreTrainedTokenizerFast (ModernBERT model)
• moonshine — PreTrainedTokenizerFast (Moonshine model)
• moshi — PreTrainedTokenizerFast (Moshi model)
• mpnet — MPNetTokenizer or MPNetTokenizerFast (MPNet model)
• mpt — GPTNeoXTokenizerFast (MPT model)
• mra — RobertaTokenizer or RobertaTokenizerFast (MRA model)
• mt5 — MT5Tokenizer or MT5TokenizerFast (MT5 model)
• musicgen — T5Tokenizer or T5TokenizerFast (MusicGen model)
• musicgen_melody — T5Tokenizer or T5TokenizerFast (MusicGen Melody model)
• mvp — MvpTokenizer or MvpTokenizerFast (MVP model)
• myt5 — MyT5Tokenizer (myt5 model)
• nemotron — PreTrainedTokenizerFast (Nemotron model)
• nezha — BertTokenizer or BertTokenizerFast (Nezha model)
• nllb — NllbTokenizer or NllbTokenizerFast (NLLB model)
• nllb-moe — NllbTokenizer or NllbTokenizerFast (NLLB-MOE model)
• nystromformer — AlbertTokenizer or AlbertTokenizerFast (Nyströmformer model)
• olmo — GPTNeoXTokenizerFast (OLMo model)
• olmo2 — GPTNeoXTokenizerFast (OLMo2 model)
• olmo3 — GPT2TokenizerFast (Olmo3 model)
• olmoe — GPTNeoXTokenizerFast (OLMoE model)
• omdet-turbo — CLIPTokenizer or CLIPTokenizerFast (OmDet-Turbo model)
• oneformer — CLIPTokenizer or CLIPTokenizerFast (OneFormer model)
• openai-gpt — OpenAIGPTTokenizer or OpenAIGPTTokenizerFast (OpenAI GPT model)
• opt — GPT2Tokenizer or GPT2TokenizerFast (OPT model)
• owlv2 — CLIPTokenizer or CLIPTokenizerFast (OWLv2 model)
• owlvit — CLIPTokenizer or CLIPTokenizerFast (OWL-ViT model)
• paligemma — LlamaTokenizer or LlamaTokenizerFast (PaliGemma model)
• parakeet — ParakeetCTCTokenizer (Parakeet model)
• pegasus — PegasusTokenizer or PegasusTokenizerFast (Pegasus model)
• pegasus_x — PegasusTokenizer or PegasusTokenizerFast (PEGASUS-X model)
• perceiver — PerceiverTokenizer (Perceiver model)
• persimmon — LlamaTokenizer or LlamaTokenizerFast (Persimmon model)
• phi — CodeGenTokenizer or CodeGenTokenizerFast (Phi model)
• phi3 — LlamaTokenizer or LlamaTokenizerFast (Phi3 model)
• phimoe — LlamaTokenizer or LlamaTokenizerFast (Phimoe model)
• phobert — PhobertTokenizer (PhoBERT model)
• pix2struct — T5Tokenizer or T5TokenizerFast (Pix2Struct model)
• pixtral — MistralCommonTokenizer (Pixtral model)
• plbart — PLBartTokenizer (PLBart model)
• prophetnet — ProphetNetTokenizer (ProphetNet model)
• qdqbert — BertTokenizer or BertTokenizerFast (QDQBert model)
• qwen2 — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen2 model)
• qwen2_5_omni — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen2_5Omni model)
• qwen2_5_vl — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen2_5_VL model)
• qwen2_audio — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen2Audio model)
• qwen2_moe — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen2MoE model)
• qwen2_vl — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen2VL model)
• qwen3 — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen3 model)
• qwen3_moe — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen3MoE model)
• qwen3_next — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen3Next model)
• qwen3_omni_moe — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen3OmniMoE model)
• qwen3_vl — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen3VL model)
• qwen3_vl_moe — Qwen2Tokenizer or Qwen2TokenizerFast (Qwen3VLMoe model)
• rag — RagTokenizer (RAG model)
• realm — RealmTokenizer or RealmTokenizerFast (REALM model)
• recurrent_gemma — GemmaTokenizer or GemmaTokenizerFast (RecurrentGemma model)
• reformer — ReformerTokenizer or ReformerTokenizerFast (Reformer model)
• rembert — RemBertTokenizer or RemBertTokenizerFast (RemBERT model)
• retribert — RetriBertTokenizer or RetriBertTokenizerFast (RetriBERT model)
• roberta — RobertaTokenizer or RobertaTokenizerFast (RoBERTa model)
• roberta-prelayernorm — RobertaTokenizer or RobertaTokenizerFast (RoBERTa-PreLayerNorm model)
• roc_bert — RoCBertTokenizer (RoCBert model)
• roformer — RoFormerTokenizer or RoFormerTokenizerFast (RoFormer model)
• rwkv — GPTNeoXTokenizerFast (RWKV model)
• seamless_m4t — SeamlessM4TTokenizer or SeamlessM4TTokenizerFast (SeamlessM4T model)
• seamless_m4t_v2 — SeamlessM4TTokenizer or SeamlessM4TTokenizerFast (SeamlessM4Tv2 model)
• shieldgemma2 — GemmaTokenizer or GemmaTokenizerFast (Shieldgemma2 model)
• siglip — SiglipTokenizer (SigLIP model)
• siglip2 — GemmaTokenizer or GemmaTokenizerFast (SigLIP2 model)
• smollm3 — PreTrainedTokenizerFast (SmolLM3 model)
• speech_to_text — Speech2TextTokenizer (Speech2Text model)
• speech_to_text_2 — Speech2Text2Tokenizer (Speech2Text2 model)
• speecht5 — SpeechT5Tokenizer (SpeechT5 model)
• splinter — SplinterTokenizer or SplinterTokenizerFast (Splinter model)
• squeezebert — SqueezeBertTokenizer or SqueezeBertTokenizerFast (SqueezeBERT model)
• stablelm — GPTNeoXTokenizerFast (StableLm model)
• starcoder2 — GPT2Tokenizer or GPT2TokenizerFast (Starcoder2 model)
• switch_transformers — T5Tokenizer or T5TokenizerFast (SwitchTransformers model)
• t5 — T5Tokenizer or T5TokenizerFast (T5 model)
• t5gemma — GemmaTokenizer or GemmaTokenizerFast (T5Gemma model)
• tapas — TapasTokenizer (TAPAS model)
• tapex — TapexTokenizer (TAPEX model)
• transfo-xl — TransfoXLTokenizer (Transformer-XL model)
• tvp — BertTokenizer or BertTokenizerFast (TVP model)
• udop — UdopTokenizer or UdopTokenizerFast (UDOP model)
• umt5 — T5Tokenizer or T5TokenizerFast (UMT5 model)
• video_llava — LlamaTokenizer or LlamaTokenizerFast (VideoLlava model)
• vilt — BertTokenizer or BertTokenizerFast (ViLT model)
• vipllava — LlamaTokenizer or LlamaTokenizerFast (VipLlava model)
• visual_bert — BertTokenizer or BertTokenizerFast (VisualBERT model)
• vits — VitsTokenizer (VITS model)
• voxtral — MistralCommonTokenizer (Voxtral model)
• wav2vec2 — Wav2Vec2CTCTokenizer (Wav2Vec2 model)
• wav2vec2-bert — Wav2Vec2CTCTokenizer (Wav2Vec2-BERT model)
• wav2vec2-conformer — Wav2Vec2CTCTokenizer (Wav2Vec2-Conformer model)
• wav2vec2_phoneme — Wav2Vec2PhonemeCTCTokenizer (Wav2Vec2Phoneme model)
• whisper — WhisperTokenizer or WhisperTokenizerFast (Whisper model)
• xclip — CLIPTokenizer or CLIPTokenizerFast (X-CLIP model)
• xglm — XGLMTokenizer or XGLMTokenizerFast (XGLM model)
• xlm — XLMTokenizer (XLM model)
• xlm-prophetnet — XLMProphetNetTokenizer (XLM-ProphetNet model)
• xlm-roberta — XLMRobertaTokenizer or XLMRobertaTokenizerFast (XLM-RoBERTa model)
• xlm-roberta-xl — XLMRobertaTokenizer or XLMRobertaTokenizerFast (XLM-RoBERTa-XL model)
• xlnet — XLNetTokenizer or XLNetTokenizerFast (XLNet model)
• xlstm — GPTNeoXTokenizerFast (xLSTM model)
• xmod — XLMRobertaTokenizer or XLMRobertaTokenizerFast (X-MOD model)
• yoso — AlbertTokenizer or AlbertTokenizerFast (YOSO model)
• zamba — LlamaTokenizer or LlamaTokenizerFast (Zamba model)
• zamba2 — LlamaTokenizer or LlamaTokenizerFast (Zamba2 model)

>>> from transformers import AutoTokenizer

>>> # Download vocabulary from huggingface.co and cache.
>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased")

>>> # Download vocabulary from huggingface.co (user-uploaded) and cache.
>>> tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-german-cased")

>>> # If vocabulary files are in a directory (e.g. tokenizer was saved using *save_pretrained('./test/saved_model/')*)
>>> # tokenizer = AutoTokenizer.from_pretrained("./test/bert_saved_model/")

>>> # Download vocabulary from huggingface.co and define model-specific arguments
>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base", add_prefix_space=True)

Register a new tokenizer in this mapping.

Instantiate one of the feature extractor classes of the library from a pretrained model vocabulary.

The feature extractor class to instantiate is selected based on the model_type property of the config object (either passed as an argument or loaded from pretrained_model_name_or_path if possible), or when it’s missing, by falling back to using pattern matching on pretrained_model_name_or_path:

• audio-spectrogram-transformer — ASTFeatureExtractor (Audio Spectrogram Transformer model)
• beit — BeitFeatureExtractor (BEiT model)
• chinese_clip — ChineseCLIPFeatureExtractor (Chinese-CLIP model)
• clap — ClapFeatureExtractor (CLAP model)
• clip — CLIPFeatureExtractor (CLIP model)
• clipseg — ViTFeatureExtractor (CLIPSeg model)
• clvp — ClvpFeatureExtractor (CLVP model)
• conditional_detr — ConditionalDetrFeatureExtractor (Conditional DETR model)
• convnext — ConvNextFeatureExtractor (ConvNeXT model)
• cvt — ConvNextFeatureExtractor (CvT model)
• dac — DacFeatureExtractor (DAC model)
• data2vec-audio — Wav2Vec2FeatureExtractor (Data2VecAudio model)
• data2vec-vision — BeitFeatureExtractor (Data2VecVision model)
• deformable_detr — DeformableDetrFeatureExtractor (Deformable DETR model)
• deit — DeiTFeatureExtractor (DeiT model)
• detr — DetrFeatureExtractor (DETR model)
• dia — DiaFeatureExtractor (Dia model)
• dinat — ViTFeatureExtractor (DiNAT model)
• donut-swin — DonutFeatureExtractor (DonutSwin model)
• dpt — DPTFeatureExtractor (DPT model)
• encodec — EncodecFeatureExtractor (EnCodec model)
• flava — FlavaFeatureExtractor (FLAVA model)
• gemma3n — Gemma3nAudioFeatureExtractor (Gemma3nForConditionalGeneration model)
• glpn — GLPNFeatureExtractor (GLPN model)
• granite_speech — GraniteSpeechFeatureExtractor (GraniteSpeech model)
• groupvit — CLIPFeatureExtractor (GroupViT model)
• hubert — Wav2Vec2FeatureExtractor (Hubert model)
• imagegpt — ImageGPTFeatureExtractor (ImageGPT model)
• kyutai_speech_to_text — KyutaiSpeechToTextFeatureExtractor (KyutaiSpeechToText model)
• layoutlmv2 — LayoutLMv2FeatureExtractor (LayoutLMv2 model)
• layoutlmv3 — LayoutLMv3FeatureExtractor (LayoutLMv3 model)
• levit — LevitFeatureExtractor (LeViT model)
• maskformer — MaskFormerFeatureExtractor (MaskFormer model)
• mctct — MCTCTFeatureExtractor (M-CTC-T model)
• mimi — EncodecFeatureExtractor (Mimi model)
• mobilenet_v1 — MobileNetV1FeatureExtractor (MobileNetV1 model)
• mobilenet_v2 — MobileNetV2FeatureExtractor (MobileNetV2 model)
• mobilevit — MobileViTFeatureExtractor (MobileViT model)
• moonshine — Wav2Vec2FeatureExtractor (Moonshine model)
• moshi — EncodecFeatureExtractor (Moshi model)
• nat — ViTFeatureExtractor (NAT model)
• owlvit — OwlViTFeatureExtractor (OWL-ViT model)
• parakeet_ctc — ParakeetFeatureExtractor (Parakeet model)
• parakeet_encoder — ParakeetFeatureExtractor (ParakeetEncoder model)
• perceiver — PerceiverFeatureExtractor (Perceiver model)
• phi4_multimodal — Phi4MultimodalFeatureExtractor (Phi4Multimodal model)
• poolformer — PoolFormerFeatureExtractor (PoolFormer model)
• pop2piano — Pop2PianoFeatureExtractor (Pop2Piano model)
• regnet — ConvNextFeatureExtractor (RegNet model)
• resnet — ConvNextFeatureExtractor (ResNet model)
• seamless_m4t — SeamlessM4TFeatureExtractor (SeamlessM4T model)
• seamless_m4t_v2 — SeamlessM4TFeatureExtractor (SeamlessM4Tv2 model)
• segformer — SegformerFeatureExtractor (SegFormer model)
• sew — Wav2Vec2FeatureExtractor (SEW model)
• sew-d — Wav2Vec2FeatureExtractor (SEW-D model)
• speech_to_text — Speech2TextFeatureExtractor (Speech2Text model)
• speecht5 — SpeechT5FeatureExtractor (SpeechT5 model)
• swiftformer — ViTFeatureExtractor (SwiftFormer model)
• swin — ViTFeatureExtractor (Swin Transformer model)
• swinv2 — ViTFeatureExtractor (Swin Transformer V2 model)
• table-transformer — DetrFeatureExtractor (Table Transformer model)
• timesformer — VideoMAEFeatureExtractor (TimeSformer model)
• tvlt — TvltFeatureExtractor (TVLT model)
• unispeech — Wav2Vec2FeatureExtractor (UniSpeech model)
• unispeech-sat — Wav2Vec2FeatureExtractor (UniSpeechSat model)
• univnet — UnivNetFeatureExtractor (UnivNet model)
• van — ConvNextFeatureExtractor (VAN model)
• videomae — VideoMAEFeatureExtractor (VideoMAE model)
• vilt — ViltFeatureExtractor (ViLT model)
• vit — ViTFeatureExtractor (ViT model)
• vit_mae — ViTFeatureExtractor (ViTMAE model)
• vit_msn — ViTFeatureExtractor (ViTMSN model)
• wav2vec2 — Wav2Vec2FeatureExtractor (Wav2Vec2 model)
• wav2vec2-bert — Wav2Vec2FeatureExtractor (Wav2Vec2-BERT model)
• wav2vec2-conformer — Wav2Vec2FeatureExtractor (Wav2Vec2-Conformer model)
• wavlm — Wav2Vec2FeatureExtractor (WavLM model)
• whisper — WhisperFeatureExtractor (Whisper model)
• xclip — CLIPFeatureExtractor (X-CLIP model)
• xcodec — DacFeatureExtractor (X-CODEC model)
• yolos — YolosFeatureExtractor (YOLOS model)

Passing token=True is required when you want to use a private model.

>>> from transformers import AutoFeatureExtractor

>>> # Download feature extractor from huggingface.co and cache.
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")

>>> # If feature extractor files are in a directory (e.g. feature extractor was saved using *save_pretrained('./test/saved_model/')*)
>>> # feature_extractor = AutoFeatureExtractor.from_pretrained("./test/saved_model/")

Register a new feature extractor for this class.

Instantiate one of the image processor classes of the library from a pretrained model vocabulary.

The image processor class to instantiate is selected based on the model_type property of the config object (either passed as an argument or loaded from pretrained_model_name_or_path if possible), or when it’s missing, by falling back to using pattern matching on pretrained_model_name_or_path:

• aimv2 — CLIPImageProcessor or CLIPImageProcessorFast (AIMv2 model)
• aimv2_vision_model — CLIPImageProcessor or CLIPImageProcessorFast (Aimv2VisionModel model)
• align — EfficientNetImageProcessor or EfficientNetImageProcessorFast (ALIGN model)
• aria — AriaImageProcessor (Aria model)
• beit — BeitImageProcessor or BeitImageProcessorFast (BEiT model)
• bit — BitImageProcessor or BitImageProcessorFast (BiT model)
• blip — BlipImageProcessor or BlipImageProcessorFast (BLIP model)
• blip-2 — BlipImageProcessor or BlipImageProcessorFast (BLIP-2 model)
• bridgetower — BridgeTowerImageProcessor or BridgeTowerImageProcessorFast (BridgeTower model)
• chameleon — ChameleonImageProcessor or ChameleonImageProcessorFast (Chameleon model)
• chinese_clip — ChineseCLIPImageProcessor or ChineseCLIPImageProcessorFast (Chinese-CLIP model)
• clip — CLIPImageProcessor or CLIPImageProcessorFast (CLIP model)
• clipseg — ViTImageProcessor or ViTImageProcessorFast (CLIPSeg model)
• cohere2_vision — Cohere2VisionImageProcessorFast (Cohere2Vision model)
• conditional_detr — ConditionalDetrImageProcessor or ConditionalDetrImageProcessorFast (Conditional DETR model)
• convnext — ConvNextImageProcessor or ConvNextImageProcessorFast (ConvNeXT model)
• convnextv2 — ConvNextImageProcessor or ConvNextImageProcessorFast (ConvNeXTV2 model)
• cvt — ConvNextImageProcessor or ConvNextImageProcessorFast (CvT model)
• data2vec-vision — BeitImageProcessor or BeitImageProcessorFast (Data2VecVision model)
• deepseek_vl — DeepseekVLImageProcessor or DeepseekVLImageProcessorFast (DeepseekVL model)
• deepseek_vl_hybrid — DeepseekVLHybridImageProcessor or DeepseekVLHybridImageProcessorFast (DeepseekVLHybrid model)
• deformable_detr — DeformableDetrImageProcessor or DeformableDetrImageProcessorFast (Deformable DETR model)
• deit — DeiTImageProcessor or DeiTImageProcessorFast (DeiT model)
• depth_anything — DPTImageProcessor or DPTImageProcessorFast (Depth Anything model)
• depth_pro — DepthProImageProcessor or DepthProImageProcessorFast (DepthPro model)
• deta — DetaImageProcessor (DETA model)
• detr — DetrImageProcessor or DetrImageProcessorFast (DETR model)
• dinat — ViTImageProcessor or ViTImageProcessorFast (DiNAT model)
• dinov2 — BitImageProcessor or BitImageProcessorFast (DINOv2 model)
• dinov3_vit — DINOv3ViTImageProcessorFast (DINOv3 ViT model)
• donut-swin — DonutImageProcessor or DonutImageProcessorFast (DonutSwin model)
• dpt — DPTImageProcessor or DPTImageProcessorFast (DPT model)
• edgetam — Sam2ImageProcessorFast (EdgeTAM model)
• efficientformer — EfficientFormerImageProcessor (EfficientFormer model)
• efficientloftr — EfficientLoFTRImageProcessor or EfficientLoFTRImageProcessorFast (EfficientLoFTR model)
• efficientnet — EfficientNetImageProcessor or EfficientNetImageProcessorFast (EfficientNet model)
• eomt — EomtImageProcessor or EomtImageProcessorFast (EoMT model)
• flava — FlavaImageProcessor or FlavaImageProcessorFast (FLAVA model)
• focalnet — BitImageProcessor or BitImageProcessorFast (FocalNet model)
• fuyu — FuyuImageProcessor (Fuyu model)
• gemma3 — Gemma3ImageProcessor or Gemma3ImageProcessorFast (Gemma3ForConditionalGeneration model)
• gemma3n — SiglipImageProcessor or SiglipImageProcessorFast (Gemma3nForConditionalGeneration model)
• git — CLIPImageProcessor or CLIPImageProcessorFast (GIT model)
• glm4v — Glm4vImageProcessor or Glm4vImageProcessorFast (GLM4V model)
• glpn — GLPNImageProcessor (GLPN model)
• got_ocr2 — GotOcr2ImageProcessor or GotOcr2ImageProcessorFast (GOT-OCR2 model)
• grounding-dino — GroundingDinoImageProcessor or GroundingDinoImageProcessorFast (Grounding DINO model)
• groupvit — CLIPImageProcessor or CLIPImageProcessorFast (GroupViT model)
• hiera — BitImageProcessor or BitImageProcessorFast (Hiera model)
• idefics — IdeficsImageProcessor (IDEFICS model)
• idefics2 — Idefics2ImageProcessor or Idefics2ImageProcessorFast (Idefics2 model)
• idefics3 — Idefics3ImageProcessor or Idefics3ImageProcessorFast (Idefics3 model)
• ijepa — ViTImageProcessor or ViTImageProcessorFast (I-JEPA model)
• imagegpt — ImageGPTImageProcessor or ImageGPTImageProcessorFast (ImageGPT model)
• instructblip — BlipImageProcessor or BlipImageProcessorFast (InstructBLIP model)
• instructblipvideo — InstructBlipVideoImageProcessor (InstructBlipVideo model)
• janus — JanusImageProcessor or JanusImageProcessorFast (Janus model)
• kosmos-2 — CLIPImageProcessor or CLIPImageProcessorFast (KOSMOS-2 model)
• kosmos-2.5 — Kosmos2_5ImageProcessor or Kosmos2_5ImageProcessorFast (KOSMOS-2.5 model)
• layoutlmv2 — LayoutLMv2ImageProcessor or LayoutLMv2ImageProcessorFast (LayoutLMv2 model)
• layoutlmv3 — LayoutLMv3ImageProcessor or LayoutLMv3ImageProcessorFast (LayoutLMv3 model)
• levit — LevitImageProcessor or LevitImageProcessorFast (LeViT model)
• lfm2_vl — Lfm2VlImageProcessorFast (Lfm2Vl model)
• lightglue — LightGlueImageProcessor (LightGlue model)
• llama4 — Llama4ImageProcessor or Llama4ImageProcessorFast (Llama4 model)
• llava — LlavaImageProcessor or LlavaImageProcessorFast (LLaVa model)
• llava_next — LlavaNextImageProcessor or LlavaNextImageProcessorFast (LLaVA-NeXT model)
• llava_next_video — LlavaNextVideoImageProcessor (LLaVa-NeXT-Video model)
• llava_onevision — LlavaOnevisionImageProcessor or LlavaOnevisionImageProcessorFast (LLaVA-Onevision model)
• mask2former — Mask2FormerImageProcessor or Mask2FormerImageProcessorFast (Mask2Former model)
• maskformer — MaskFormerImageProcessor or MaskFormerImageProcessorFast (MaskFormer model)
• metaclip_2 — CLIPImageProcessor or CLIPImageProcessorFast (MetaCLIP 2 model)
• mgp-str — ViTImageProcessor or ViTImageProcessorFast (MGP-STR model)
• mistral3 — PixtralImageProcessor or PixtralImageProcessorFast (Mistral3 model)
• mlcd — CLIPImageProcessor or CLIPImageProcessorFast (MLCD model)
• mllama — MllamaImageProcessor (Mllama model)
• mm-grounding-dino — GroundingDinoImageProcessor or GroundingDinoImageProcessorFast (MM Grounding DINO model)
• mobilenet_v1 — MobileNetV1ImageProcessor or MobileNetV1ImageProcessorFast (MobileNetV1 model)
• mobilenet_v2 — MobileNetV2ImageProcessor or MobileNetV2ImageProcessorFast (MobileNetV2 model)
• mobilevit — MobileViTImageProcessor or MobileViTImageProcessorFast (MobileViT model)
• mobilevitv2 — MobileViTImageProcessor or MobileViTImageProcessorFast (MobileViTV2 model)
• nat — ViTImageProcessor or ViTImageProcessorFast (NAT model)
• nougat — NougatImageProcessor or NougatImageProcessorFast (Nougat model)
• oneformer — OneFormerImageProcessor or OneFormerImageProcessorFast (OneFormer model)
• ovis2 — Ovis2ImageProcessor or Ovis2ImageProcessorFast (Ovis2 model)
• owlv2 — Owlv2ImageProcessor or Owlv2ImageProcessorFast (OWLv2 model)
• owlvit — OwlViTImageProcessor or OwlViTImageProcessorFast (OWL-ViT model)
• paligemma — SiglipImageProcessor or SiglipImageProcessorFast (PaliGemma model)
• perceiver — PerceiverImageProcessor or PerceiverImageProcessorFast (Perceiver model)
• perception_lm — PerceptionLMImageProcessorFast (PerceptionLM model)
• phi4_multimodal — Phi4MultimodalImageProcessorFast (Phi4Multimodal model)
• pix2struct — Pix2StructImageProcessor (Pix2Struct model)
• pixtral — PixtralImageProcessor or PixtralImageProcessorFast (Pixtral model)
• poolformer — PoolFormerImageProcessor or PoolFormerImageProcessorFast (PoolFormer model)
• prompt_depth_anything — PromptDepthAnythingImageProcessor or PromptDepthAnythingImageProcessorFast (PromptDepthAnything model)
• pvt — PvtImageProcessor or PvtImageProcessorFast (PVT model)
• pvt_v2 — PvtImageProcessor or PvtImageProcessorFast (PVTv2 model)
• qwen2_5_vl — Qwen2VLImageProcessor or Qwen2VLImageProcessorFast (Qwen2_5_VL model)
• qwen2_vl — Qwen2VLImageProcessor or Qwen2VLImageProcessorFast (Qwen2VL model)
• qwen3_vl — Qwen2VLImageProcessor or Qwen2VLImageProcessorFast (Qwen3VL model)
• regnet — ConvNextImageProcessor or ConvNextImageProcessorFast (RegNet model)
• resnet — ConvNextImageProcessor or ConvNextImageProcessorFast (ResNet model)
• rt_detr — RTDetrImageProcessor or RTDetrImageProcessorFast (RT-DETR model)
• sam — SamImageProcessor or SamImageProcessorFast (SAM model)
• sam2 — Sam2ImageProcessorFast (SAM2 model)
• sam_hq — SamImageProcessor or SamImageProcessorFast (SAM-HQ model)
• segformer — SegformerImageProcessor or SegformerImageProcessorFast (SegFormer model)
• seggpt — SegGptImageProcessor (SegGPT model)
• shieldgemma2 — Gemma3ImageProcessor or Gemma3ImageProcessorFast (Shieldgemma2 model)
• siglip — SiglipImageProcessor or SiglipImageProcessorFast (SigLIP model)
• siglip2 — Siglip2ImageProcessor or Siglip2ImageProcessorFast (SigLIP2 model)
• smolvlm — SmolVLMImageProcessor or SmolVLMImageProcessorFast (SmolVLM model)
• superglue — SuperGlueImageProcessor (SuperGlue model)
• superpoint — SuperPointImageProcessor or SuperPointImageProcessorFast (SuperPoint model)
• swiftformer — ViTImageProcessor or ViTImageProcessorFast (SwiftFormer model)
• swin — ViTImageProcessor or ViTImageProcessorFast (Swin Transformer model)
• swin2sr — Swin2SRImageProcessor or Swin2SRImageProcessorFast (Swin2SR model)
• swinv2 — ViTImageProcessor or ViTImageProcessorFast (Swin Transformer V2 model)
• table-transformer — DetrImageProcessor or DetrImageProcessorFast (Table Transformer model)
• textnet — TextNetImageProcessor or TextNetImageProcessorFast (TextNet model)
• timesformer — VideoMAEImageProcessor (TimeSformer model)
• timm_wrapper — TimmWrapperImageProcessor (TimmWrapperModel model)
• tvlt — TvltImageProcessor (TVLT model)
• tvp — TvpImageProcessor or TvpImageProcessorFast (TVP model)
• udop — LayoutLMv3ImageProcessor or LayoutLMv3ImageProcessorFast (UDOP model)
• upernet — SegformerImageProcessor or SegformerImageProcessorFast (UPerNet model)
• van — ConvNextImageProcessor or ConvNextImageProcessorFast (VAN model)
• videomae — VideoMAEImageProcessor (VideoMAE model)
• vilt — ViltImageProcessor or ViltImageProcessorFast (ViLT model)
• vipllava — CLIPImageProcessor or CLIPImageProcessorFast (VipLlava model)
• vit — ViTImageProcessor or ViTImageProcessorFast (ViT model)
• vit_hybrid — ViTHybridImageProcessor (ViT Hybrid model)
• vit_mae — ViTImageProcessor or ViTImageProcessorFast (ViTMAE model)
• vit_msn — ViTImageProcessor or ViTImageProcessorFast (ViTMSN model)
• vitmatte — VitMatteImageProcessor or VitMatteImageProcessorFast (ViTMatte model)
• xclip — CLIPImageProcessor or CLIPImageProcessorFast (X-CLIP model)
• yolos — YolosImageProcessor or YolosImageProcessorFast (YOLOS model)
• zoedepth — ZoeDepthImageProcessor or ZoeDepthImageProcessorFast (ZoeDepth model)

Passing token=True is required when you want to use a private model.

>>> from transformers import AutoImageProcessor

>>> # Download image processor from huggingface.co and cache.
>>> image_processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")

>>> # If image processor files are in a directory (e.g. image processor was saved using *save_pretrained('./test/saved_model/')*)
>>> # image_processor = AutoImageProcessor.from_pretrained("./test/saved_model/")

Register a new image processor for this class.

Instantiate one of the processor classes of the library from a pretrained model vocabulary.

The processor class to instantiate is selected based on the model_type property of the config object (either passed as an argument or loaded from pretrained_model_name_or_path if possible):

• aimv2 — CLIPProcessor (AIMv2 model)
• align — AlignProcessor (ALIGN model)
• altclip — AltCLIPProcessor (AltCLIP model)
• aria — AriaProcessor (Aria model)
• aya_vision — AyaVisionProcessor (AyaVision model)
• bark — BarkProcessor (Bark model)
• blip — BlipProcessor (BLIP model)
• blip-2 — Blip2Processor (BLIP-2 model)
• bridgetower — BridgeTowerProcessor (BridgeTower model)
• chameleon — ChameleonProcessor (Chameleon model)
• chinese_clip — ChineseCLIPProcessor (Chinese-CLIP model)
• clap — ClapProcessor (CLAP model)
• clip — CLIPProcessor (CLIP model)
• clipseg — CLIPSegProcessor (CLIPSeg model)
• clvp — ClvpProcessor (CLVP model)
• cohere2_vision — Cohere2VisionProcessor (Cohere2Vision model)
• colpali — ColPaliProcessor (ColPali model)
• colqwen2 — ColQwen2Processor (ColQwen2 model)
• deepseek_vl — DeepseekVLProcessor (DeepseekVL model)
• deepseek_vl_hybrid — DeepseekVLHybridProcessor (DeepseekVLHybrid model)
• dia — DiaProcessor (Dia model)
• edgetam — Sam2Processor (EdgeTAM model)
• emu3 — Emu3Processor (Emu3 model)
• evolla — EvollaProcessor (Evolla model)
• flava — FlavaProcessor (FLAVA model)
• florence2 — Florence2Processor (Florence2 model)
• fuyu — FuyuProcessor (Fuyu model)
• gemma3 — Gemma3Processor (Gemma3ForConditionalGeneration model)
• gemma3n — Gemma3nProcessor (Gemma3nForConditionalGeneration model)
• git — GitProcessor (GIT model)
• glm4v — Glm4vProcessor (GLM4V model)
• glm4v_moe — Glm4vProcessor (GLM4VMOE model)
• got_ocr2 — GotOcr2Processor (GOT-OCR2 model)
• granite_speech — GraniteSpeechProcessor (GraniteSpeech model)
• grounding-dino — GroundingDinoProcessor (Grounding DINO model)
• groupvit — CLIPProcessor (GroupViT model)
• hubert — Wav2Vec2Processor (Hubert model)
• idefics — IdeficsProcessor (IDEFICS model)
• idefics2 — Idefics2Processor (Idefics2 model)
• idefics3 — Idefics3Processor (Idefics3 model)
• instructblip — InstructBlipProcessor (InstructBLIP model)
• instructblipvideo — InstructBlipVideoProcessor (InstructBlipVideo model)
• internvl — InternVLProcessor (InternVL model)
• janus — JanusProcessor (Janus model)
• kosmos-2 — Kosmos2Processor (KOSMOS-2 model)
• kosmos-2.5 — Kosmos2_5Processor (KOSMOS-2.5 model)
• kyutai_speech_to_text — KyutaiSpeechToTextProcessor (KyutaiSpeechToText model)
• layoutlmv2 — LayoutLMv2Processor (LayoutLMv2 model)
• layoutlmv3 — LayoutLMv3Processor (LayoutLMv3 model)
• lfm2_vl — Lfm2VlProcessor (Lfm2Vl model)
• llama4 — Llama4Processor (Llama4 model)
• llava — LlavaProcessor (LLaVa model)
• llava_next — LlavaNextProcessor (LLaVA-NeXT model)
• llava_next_video — LlavaNextVideoProcessor (LLaVa-NeXT-Video model)
• llava_onevision — LlavaOnevisionProcessor (LLaVA-Onevision model)
• markuplm — MarkupLMProcessor (MarkupLM model)
• mctct — MCTCTProcessor (M-CTC-T model)
• metaclip_2 — CLIPProcessor (MetaCLIP 2 model)
• mgp-str — MgpstrProcessor (MGP-STR model)
• mistral3 — PixtralProcessor (Mistral3 model)
• mllama — MllamaProcessor (Mllama model)
• mm-grounding-dino — GroundingDinoProcessor (MM Grounding DINO model)
• moonshine — Wav2Vec2Processor (Moonshine model)
• oneformer — OneFormerProcessor (OneFormer model)
• ovis2 — Ovis2Processor (Ovis2 model)
• owlv2 — Owlv2Processor (OWLv2 model)
• owlvit — OwlViTProcessor (OWL-ViT model)
• paligemma — PaliGemmaProcessor (PaliGemma model)
• perception_lm — PerceptionLMProcessor (PerceptionLM model)
• phi4_multimodal — Phi4MultimodalProcessor (Phi4Multimodal model)
• pix2struct — Pix2StructProcessor (Pix2Struct model)
• pixtral — PixtralProcessor (Pixtral model)
• pop2piano — Pop2PianoProcessor (Pop2Piano model)
• qwen2_5_omni — Qwen2_5OmniProcessor (Qwen2_5Omni model)
• qwen2_5_vl — Qwen2_5_VLProcessor (Qwen2_5_VL model)
• qwen2_audio — Qwen2AudioProcessor (Qwen2Audio model)
• qwen2_vl — Qwen2VLProcessor (Qwen2VL model)
• qwen3_omni_moe — Qwen3OmniMoeProcessor (Qwen3OmniMoE model)
• qwen3_vl — Qwen3VLProcessor (Qwen3VL model)
• qwen3_vl_moe — Qwen3VLProcessor (Qwen3VLMoe model)
• sam — SamProcessor (SAM model)
• sam2 — Sam2Processor (SAM2 model)
• sam_hq — SamHQProcessor (SAM-HQ model)
• seamless_m4t — SeamlessM4TProcessor (SeamlessM4T model)
• sew — Wav2Vec2Processor (SEW model)
• sew-d — Wav2Vec2Processor (SEW-D model)
• shieldgemma2 — ShieldGemma2Processor (Shieldgemma2 model)
• siglip — SiglipProcessor (SigLIP model)
• siglip2 — Siglip2Processor (SigLIP2 model)
• smolvlm — SmolVLMProcessor (SmolVLM model)
• speech_to_text — Speech2TextProcessor (Speech2Text model)
• speech_to_text_2 — Speech2Text2Processor (Speech2Text2 model)
• speecht5 — SpeechT5Processor (SpeechT5 model)
• trocr — TrOCRProcessor (TrOCR model)
• tvlt — TvltProcessor (TVLT model)
• tvp — TvpProcessor (TVP model)
• udop — UdopProcessor (UDOP model)
• unispeech — Wav2Vec2Processor (UniSpeech model)
• unispeech-sat — Wav2Vec2Processor (UniSpeechSat model)
• video_llava — VideoLlavaProcessor (VideoLlava model)
• vilt — ViltProcessor (ViLT model)
• vipllava — LlavaProcessor (VipLlava model)
• vision-text-dual-encoder — VisionTextDualEncoderProcessor (VisionTextDualEncoder model)
• voxtral — VoxtralProcessor (Voxtral model)
• wav2vec2 — Wav2Vec2Processor (Wav2Vec2 model)
• wav2vec2-bert — Wav2Vec2Processor (Wav2Vec2-BERT model)
• wav2vec2-conformer — Wav2Vec2Processor (Wav2Vec2-Conformer model)
• wavlm — Wav2Vec2Processor (WavLM model)
• whisper — WhisperProcessor (Whisper model)
• xclip — XCLIPProcessor (X-CLIP model)

Passing token=True is required when you want to use a private model.

>>> from transformers import AutoProcessor

>>> # Download processor from huggingface.co and cache.
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")

>>> # If processor files are in a directory (e.g. processor was saved using *save_pretrained('./test/saved_model/')*)
>>> # processor = AutoProcessor.from_pretrained("./test/saved_model/")

Register a new processor for this class.

Instantiates one of the base model classes of the library from a configuration.

Note: Loading a model from its configuration file does not load the model weights. It only affects the model’s configuration. Use from_pretrained() to load the model weights.

>>> from transformers import AutoConfig, AutoModel

>>> # Download configuration from huggingface.co and cache.
>>> config = AutoConfig.from_pretrained("google-bert/bert-base-cased")
>>> model = AutoModel.from_config(config)

Instantiate one of the base model classes of the library from a pretrained model.

The model class to instantiate is selected based on the model_type property of the config object (either passed as an argument or loaded from pretrained_model_name_or_path if possible), or when it’s missing, by falling back to using pattern matching on pretrained_model_name_or_path:

• aimv2 — Aimv2Model (AIMv2 model)
• aimv2_vision_model — Aimv2VisionModel (Aimv2VisionModel model)
• albert — AlbertModel (ALBERT model)
• align — AlignModel (ALIGN model)
• altclip — AltCLIPModel (AltCLIP model)
• apertus — ApertusModel (Apertus model)
• arcee — ArceeModel (Arcee model)
• aria — AriaModel (Aria model)
• aria_text — AriaTextModel (AriaText model)
• audio-spectrogram-transformer — ASTModel (Audio Spectrogram Transformer model)
• autoformer — AutoformerModel (Autoformer model)
• aya_vision — AyaVisionModel (AyaVision model)
• bamba — BambaModel (Bamba model)
• bark — BarkModel (Bark model)
• bart — BartModel (BART model)
• beit — BeitModel (BEiT model)
• bert — BertModel (BERT model)
• bert-generation — BertGenerationEncoder (Bert Generation model)
• big_bird — BigBirdModel (BigBird model)
• bigbird_pegasus — BigBirdPegasusModel (BigBird-Pegasus model)
• biogpt — BioGptModel (BioGpt model)
• bit — BitModel (BiT model)
• bitnet — BitNetModel (BitNet model)
• blenderbot — BlenderbotModel (Blenderbot model)
• blenderbot-small — BlenderbotSmallModel (BlenderbotSmall model)
• blip — BlipModel (BLIP model)
• blip-2 — Blip2Model (BLIP-2 model)
• blip_2_qformer — Blip2QFormerModel (BLIP-2 QFormer model)
• bloom — BloomModel (BLOOM model)
• blt — BltModel (Blt model)
• bridgetower — BridgeTowerModel (BridgeTower model)
• bros — BrosModel (BROS model)
• camembert — CamembertModel (CamemBERT model)
• canine — CanineModel (CANINE model)
• chameleon — ChameleonModel (Chameleon model)
• chinese_clip — ChineseCLIPModel (Chinese-CLIP model)
• chinese_clip_vision_model — ChineseCLIPVisionModel (ChineseCLIPVisionModel model)
• clap — ClapModel (CLAP model)
• clip — CLIPModel (CLIP model)
• clip_text_model — CLIPTextModel (CLIPTextModel model)
• clip_vision_model — CLIPVisionModel (CLIPVisionModel model)
• clipseg — CLIPSegModel (CLIPSeg model)
• clvp — ClvpModelForConditionalGeneration (CLVP model)
• code_llama — LlamaModel (CodeLlama model)
• codegen — CodeGenModel (CodeGen model)
• cohere — CohereModel (Cohere model)
• cohere2 — Cohere2Model (Cohere2 model)
• cohere2_vision — Cohere2VisionModel (Cohere2Vision model)
• conditional_detr — ConditionalDetrModel (Conditional DETR model)
• convbert — ConvBertModel (ConvBERT model)
• convnext — ConvNextModel (ConvNeXT model)
• convnextv2 — ConvNextV2Model (ConvNeXTV2 model)
• cpmant — CpmAntModel (CPM-Ant model)
• csm — CsmForConditionalGeneration (CSM model)
• ctrl — CTRLModel (CTRL model)
• cvt — CvtModel (CvT model)
• d_fine — DFineModel (D-FINE model)
• dab-detr — DabDetrModel (DAB-DETR model)
• dac — DacModel (DAC model)
• data2vec-audio — Data2VecAudioModel (Data2VecAudio model)
• data2vec-text — Data2VecTextModel (Data2VecText model)
• data2vec-vision — Data2VecVisionModel (Data2VecVision model)
• dbrx — DbrxModel (DBRX model)
• deberta — DebertaModel (DeBERTa model)
• deberta-v2 — DebertaV2Model (DeBERTa-v2 model)
• decision_transformer — DecisionTransformerModel (Decision Transformer model)
• deepseek_v2 — DeepseekV2Model (DeepSeek-V2 model)
• deepseek_v3 — DeepseekV3Model (DeepSeek-V3 model)
• deepseek_vl — DeepseekVLModel (DeepseekVL model)
• deepseek_vl_hybrid — DeepseekVLHybridModel (DeepseekVLHybrid model)
• deformable_detr — DeformableDetrModel (Deformable DETR model)
• deit — DeiTModel (DeiT model)
• depth_pro — DepthProModel (DepthPro model)
• deta — DetaModel (DETA model)
• detr — DetrModel (DETR model)
• dia — DiaModel (Dia model)
• diffllama — DiffLlamaModel (DiffLlama model)
• dinat — DinatModel (DiNAT model)
• dinov2 — Dinov2Model (DINOv2 model)
• dinov2_with_registers — Dinov2WithRegistersModel (DINOv2 with Registers model)
• dinov3_convnext — DINOv3ConvNextModel (DINOv3 ConvNext model)
• dinov3_vit — DINOv3ViTModel (DINOv3 ViT model)
• distilbert — DistilBertModel (DistilBERT model)
• doge — DogeModel (Doge model)
• donut-swin — DonutSwinModel (DonutSwin model)
• dots1 — Dots1Model (dots1 model)
• dpr — DPRQuestionEncoder (DPR model)
• dpt — DPTModel (DPT model)
• edgetam — EdgeTamModel (EdgeTAM model)
• edgetam_video — EdgeTamVideoModel (EdgeTamVideo model)
• edgetam_vision_model — EdgeTamVisionModel (EdgeTamVisionModel model)
• efficientformer — EfficientFormerModel (EfficientFormer model)
• efficientloftr — EfficientLoFTRModel (EfficientLoFTR model)
• efficientnet — EfficientNetModel (EfficientNet model)
• electra — ElectraModel (ELECTRA model)
• emu3 — Emu3Model (Emu3 model)
• encodec — EncodecModel (EnCodec model)
• ernie — ErnieModel (ERNIE model)
• ernie4_5 — Ernie4_5Model (Ernie4_5 model)
• ernie4_5_moe — Ernie4_5_MoeModel (Ernie4_5_MoE model)
• ernie_m — ErnieMModel (ErnieM model)
• esm — EsmModel (ESM model)
• evolla — EvollaModel (Evolla model)
• exaone4 — Exaone4Model (EXAONE-4.0 model)
• falcon — FalconModel (Falcon model)
• falcon_h1 — FalconH1Model (FalconH1 model)
• falcon_mamba — FalconMambaModel (FalconMamba model)
• fastspeech2_conformer — FastSpeech2ConformerModel (FastSpeech2Conformer model)
• fastspeech2_conformer_with_hifigan — FastSpeech2ConformerWithHifiGan (FastSpeech2ConformerWithHifiGan model)
• flaubert — FlaubertModel (FlauBERT model)
• flava — FlavaModel (FLAVA model)
• flex_olmo — FlexOlmoModel (FlexOlmo model)
• florence2 — Florence2Model (Florence2 model)
• fnet — FNetModel (FNet model)
• focalnet — FocalNetModel (FocalNet model)
• fsmt — FSMTModel (FairSeq Machine-Translation model)
• funnel — FunnelModel or FunnelBaseModel (Funnel Transformer model)
• fuyu — FuyuModel (Fuyu model)
• gemma — GemmaModel (Gemma model)
• gemma2 — Gemma2Model (Gemma2 model)
• gemma3 — Gemma3Model (Gemma3ForConditionalGeneration model)
• gemma3_text — Gemma3TextModel (Gemma3ForCausalLM model)
• gemma3n — Gemma3nModel (Gemma3nForConditionalGeneration model)
• gemma3n_audio — Gemma3nAudioEncoder (Gemma3nAudioEncoder model)
• gemma3n_text — Gemma3nTextModel (Gemma3nForCausalLM model)
• gemma3n_vision — TimmWrapperModel (TimmWrapperModel model)
• git — GitModel (GIT model)
• glm — GlmModel (GLM model)
• glm4 — Glm4Model (GLM4 model)
• glm4_moe — Glm4MoeModel (Glm4MoE model)
• glm4v — Glm4vModel (GLM4V model)
• glm4v_moe — Glm4vMoeModel (GLM4VMOE model)
• glm4v_moe_text — Glm4vMoeTextModel (GLM4VMOE model)
• glm4v_text — Glm4vTextModel (GLM4V model)
• glpn — GLPNModel (GLPN model)
• got_ocr2 — GotOcr2Model (GOT-OCR2 model)
• gpt-sw3 — GPT2Model (GPT-Sw3 model)
• gpt2 — GPT2Model (OpenAI GPT-2 model)
• gpt_bigcode — GPTBigCodeModel (GPTBigCode model)
• gpt_neo — GPTNeoModel (GPT Neo model)
• gpt_neox — GPTNeoXModel (GPT NeoX model)
• gpt_neox_japanese — GPTNeoXJapaneseModel (GPT NeoX Japanese model)
• gpt_oss — GptOssModel (GptOss model)
• gptj — GPTJModel (GPT-J model)
• gptsan-japanese — GPTSanJapaneseForConditionalGeneration (GPTSAN-japanese model)
• granite — GraniteModel (Granite model)
• granitemoe — GraniteMoeModel (GraniteMoeMoe model)
• granitemoehybrid — GraniteMoeHybridModel (GraniteMoeHybrid model)
• granitemoeshared — GraniteMoeSharedModel (GraniteMoeSharedMoe model)
• graphormer — GraphormerModel (Graphormer model)
• grounding-dino — GroundingDinoModel (Grounding DINO model)
• groupvit — GroupViTModel (GroupViT model)
• helium — HeliumModel (Helium model)
• hgnet_v2 — HGNetV2Backbone (HGNet-V2 model)
• hiera — HieraModel (Hiera model)
• hubert — HubertModel (Hubert model)
• hunyuan_v1_dense — HunYuanDenseV1Model (HunYuanDenseV1 model)
• hunyuan_v1_moe — HunYuanMoEV1Model (HunYuanMoeV1 model)
• ibert — IBertModel (I-BERT model)
• idefics — IdeficsModel (IDEFICS model)
• idefics2 — Idefics2Model (Idefics2 model)
• idefics3 — Idefics3Model (Idefics3 model)
• idefics3_vision — Idefics3VisionTransformer (Idefics3VisionTransformer model)
• ijepa — IJepaModel (I-JEPA model)
• imagegpt — ImageGPTModel (ImageGPT model)
• informer — InformerModel (Informer model)
• instructblip — InstructBlipModel (InstructBLIP model)
• instructblipvideo — InstructBlipVideoModel (InstructBlipVideo model)
• internvl — InternVLModel (InternVL model)
• internvl_vision — InternVLVisionModel (InternVLVision model)
• jamba — JambaModel (Jamba model)
• janus — JanusModel (Janus model)
• jetmoe — JetMoeModel (JetMoe model)
• jukebox — JukeboxModel (Jukebox model)
• kosmos-2 — Kosmos2Model (KOSMOS-2 model)
• kosmos-2.5 — Kosmos2_5Model (KOSMOS-2.5 model)
• kyutai_speech_to_text — KyutaiSpeechToTextModel (KyutaiSpeechToText model)
• layoutlm — LayoutLMModel (LayoutLM model)
• layoutlmv2 — LayoutLMv2Model (LayoutLMv2 model)
• layoutlmv3 — LayoutLMv3Model (LayoutLMv3 model)
• led — LEDModel (LED model)
• levit — LevitModel (LeViT model)
• lfm2 — Lfm2Model (Lfm2 model)
• lfm2_vl — Lfm2VlModel (Lfm2Vl model)
• lightglue — LightGlueForKeypointMatching (LightGlue model)
• lilt — LiltModel (LiLT model)
• llama — LlamaModel (LLaMA model)
• llama4 — Llama4ForConditionalGeneration (Llama4 model)
• llama4_text — Llama4TextModel (Llama4ForCausalLM model)
• llava — LlavaModel (LLaVa model)
• llava_next — LlavaNextModel (LLaVA-NeXT model)
• llava_next_video — LlavaNextVideoModel (LLaVa-NeXT-Video model)
• llava_onevision — LlavaOnevisionModel (LLaVA-Onevision model)
• longcat_flash — LongcatFlashModel (LongCatFlash model)
• longformer — LongformerModel (Longformer model)
• longt5 — LongT5Model (LongT5 model)
• luke — LukeModel (LUKE model)
• lxmert — LxmertModel (LXMERT model)
• m2m_100 — M2M100Model (M2M100 model)
• mamba — MambaModel (Mamba model)
• mamba2 — Mamba2Model (mamba2 model)
• marian — MarianModel (Marian model)
• markuplm — MarkupLMModel (MarkupLM model)
• mask2former — Mask2FormerModel (Mask2Former model)
• maskformer — MaskFormerModel (MaskFormer model)
• maskformer-swin — MaskFormerSwinModel (MaskFormerSwin model)
• mbart — MBartModel (mBART model)
• mctct — MCTCTModel (M-CTC-T model)
• mega — MegaModel (MEGA model)
• megatron-bert — MegatronBertModel (Megatron-BERT model)
• metaclip_2 — MetaClip2Model (MetaCLIP 2 model)
• mgp-str — MgpstrForSceneTextRecognition (MGP-STR model)
• mimi — MimiModel (Mimi model)
• minimax — MiniMaxModel (MiniMax model)
• ministral — MinistralModel (Ministral model)
• mistral — MistralModel (Mistral model)
• mistral3 — Mistral3Model (Mistral3 model)
• mixtral — MixtralModel (Mixtral model)
• mlcd — MLCDVisionModel (MLCD model)
• mllama — MllamaModel (Mllama model)
• mm-grounding-dino — MMGroundingDinoModel (MM Grounding DINO model)
• mobilebert — MobileBertModel (MobileBERT model)
• mobilenet_v1 — MobileNetV1Model (MobileNetV1 model)
• mobilenet_v2 — MobileNetV2Model (MobileNetV2 model)
• mobilevit — MobileViTModel (MobileViT model)
• mobilevitv2 — MobileViTV2Model (MobileViTV2 model)
• modernbert — ModernBertModel (ModernBERT model)
• modernbert-decoder — ModernBertDecoderModel (ModernBertDecoder model)
• moonshine — MoonshineModel (Moonshine model)
• moshi — MoshiModel (Moshi model)
• mpnet — MPNetModel (MPNet model)
• mpt — MptModel (MPT model)
• mra — MraModel (MRA model)
• mt5 — MT5Model (MT5 model)
• musicgen — MusicgenModel (MusicGen model)
• musicgen_melody — MusicgenMelodyModel (MusicGen Melody model)
• mvp — MvpModel (MVP model)
• nat — NatModel (NAT model)
• nemotron — NemotronModel (Nemotron model)
• nezha — NezhaModel (Nezha model)
• nllb-moe — NllbMoeModel (NLLB-MOE model)
• nystromformer — NystromformerModel (Nyströmformer model)
• olmo — OlmoModel (OLMo model)
• olmo2 — Olmo2Model (OLMo2 model)
• olmo3 — Olmo3Model (Olmo3 model)
• olmoe — OlmoeModel (OLMoE model)
• omdet-turbo — OmDetTurboForObjectDetection (OmDet-Turbo model)
• oneformer — OneFormerModel (OneFormer model)
• open-llama — OpenLlamaModel (OpenLlama model)
• openai-gpt — OpenAIGPTModel (OpenAI GPT model)
• opt — OPTModel (OPT model)
• ovis2 — Ovis2Model (Ovis2 model)
• owlv2 — Owlv2Model (OWLv2 model)
• owlvit — OwlViTModel (OWL-ViT model)
• paligemma — PaliGemmaModel (PaliGemma model)
• parakeet_ctc — ParakeetForCTC (Parakeet model)
• parakeet_encoder — ParakeetEncoder (ParakeetEncoder model)
• patchtsmixer — PatchTSMixerModel (PatchTSMixer model)
• patchtst — PatchTSTModel (PatchTST model)
• pegasus — PegasusModel (Pegasus model)
• pegasus_x — PegasusXModel (PEGASUS-X model)
• perceiver — PerceiverModel (Perceiver model)
• perception_encoder — PerceptionEncoder (PerceptionEncoder model)
• perception_lm — PerceptionLMModel (PerceptionLM model)
• persimmon — PersimmonModel (Persimmon model)
• phi — PhiModel (Phi model)
• phi3 — Phi3Model (Phi3 model)
• phi4_multimodal — Phi4MultimodalModel (Phi4Multimodal model)
• phimoe — PhimoeModel (Phimoe model)
• pixtral — PixtralVisionModel (Pixtral model)
• plbart — PLBartModel (PLBart model)
• poolformer — PoolFormerModel (PoolFormer model)
• prophetnet — ProphetNetModel (ProphetNet model)
• pvt — PvtModel (PVT model)
• pvt_v2 — PvtV2Model (PVTv2 model)
• qdqbert — QDQBertModel (QDQBert model)
• qwen2 — Qwen2Model (Qwen2 model)
• qwen2_5_vl — Qwen2_5_VLModel (Qwen2_5_VL model)
• qwen2_5_vl_text — Qwen2_5_VLTextModel (Qwen2_5_VL model)
• qwen2_audio_encoder — Qwen2AudioEncoder (Qwen2AudioEncoder model)
• qwen2_moe — Qwen2MoeModel (Qwen2MoE model)
• qwen2_vl — Qwen2VLModel (Qwen2VL model)
• qwen2_vl_text — Qwen2VLTextModel (Qwen2VL model)
• qwen3 — Qwen3Model (Qwen3 model)
• qwen3_moe — Qwen3MoeModel (Qwen3MoE model)
• qwen3_next — Qwen3NextModel (Qwen3Next model)
• qwen3_vl — Qwen3VLModel (Qwen3VL model)
• qwen3_vl_moe — Qwen3VLMoeModel (Qwen3VLMoe model)
• qwen3_vl_moe_text — Qwen3VLMoeTextModel (Qwen3VLMoe model)
• qwen3_vl_text — Qwen3VLTextModel (Qwen3VL model)
• recurrent_gemma — RecurrentGemmaModel (RecurrentGemma model)
• reformer — ReformerModel (Reformer model)
• regnet — RegNetModel (RegNet model)
• rembert — RemBertModel (RemBERT model)
• resnet — ResNetModel (ResNet model)
• retribert — RetriBertModel (RetriBERT model)
• roberta — RobertaModel (RoBERTa model)
• roberta-prelayernorm — RobertaPreLayerNormModel (RoBERTa-PreLayerNorm model)
• roc_bert — RoCBertModel (RoCBert model)
• roformer — RoFormerModel (RoFormer model)
• rt_detr — RTDetrModel (RT-DETR model)
• rt_detr_v2 — RTDetrV2Model (RT-DETRv2 model)
• rwkv — RwkvModel (RWKV model)
• sam — SamModel (SAM model)
• sam2 — Sam2Model (SAM2 model)
• sam2_hiera_det_model — Sam2HieraDetModel (Sam2HieraDetModel model)
• sam2_video — Sam2VideoModel (Sam2VideoModel model)
• sam2_vision_model — Sam2VisionModel (Sam2VisionModel model)
• sam_hq — SamHQModel (SAM-HQ model)
• sam_hq_vision_model — SamHQVisionModel (SamHQVisionModel model)
• sam_vision_model — SamVisionModel (SamVisionModel model)
• seamless_m4t — SeamlessM4TModel (SeamlessM4T model)
• seamless_m4t_v2 — SeamlessM4Tv2Model (SeamlessM4Tv2 model)
• seed_oss — SeedOssModel (SeedOss model)
• segformer — SegformerModel (SegFormer model)
• seggpt — SegGptModel (SegGPT model)
• sew — SEWModel (SEW model)
• sew-d — SEWDModel (SEW-D model)
• siglip — SiglipModel (SigLIP model)
• siglip2 — Siglip2Model (SigLIP2 model)
• siglip2_vision_model — Siglip2VisionModel (Siglip2VisionModel model)
• siglip_vision_model — SiglipVisionModel (SiglipVisionModel model)
• smollm3 — SmolLM3Model (SmolLM3 model)
• smolvlm — SmolVLMModel (SmolVLM model)
• smolvlm_vision — SmolVLMVisionTransformer (SmolVLMVisionTransformer model)
• speech_to_text — Speech2TextModel (Speech2Text model)
• speecht5 — SpeechT5Model (SpeechT5 model)
• splinter — SplinterModel (Splinter model)
• squeezebert — SqueezeBertModel (SqueezeBERT model)
• stablelm — StableLmModel (StableLm model)
• starcoder2 — Starcoder2Model (Starcoder2 model)
• swiftformer — SwiftFormerModel (SwiftFormer model)
• swin — SwinModel (Swin Transformer model)
• swin2sr — Swin2SRModel (Swin2SR model)
• swinv2 — Swinv2Model (Swin Transformer V2 model)
• switch_transformers — SwitchTransformersModel (SwitchTransformers model)
• t5 — T5Model (T5 model)
• t5gemma — T5GemmaModel (T5Gemma model)
• table-transformer — TableTransformerModel (Table Transformer model)
• tapas — TapasModel (TAPAS model)
• textnet — TextNetModel (TextNet model)
• time_series_transformer — TimeSeriesTransformerModel (Time Series Transformer model)
• timesfm — TimesFmModel (TimesFm model)
• timesformer — TimesformerModel (TimeSformer model)
• timm_backbone — TimmBackbone (TimmBackbone model)
• timm_wrapper — TimmWrapperModel (TimmWrapperModel model)
• trajectory_transformer — TrajectoryTransformerModel (Trajectory Transformer model)
• transfo-xl — TransfoXLModel (Transformer-XL model)
• tvlt — TvltModel (TVLT model)
• tvp — TvpModel (TVP model)
• udop — UdopModel (UDOP model)
• umt5 — UMT5Model (UMT5 model)
• unispeech — UniSpeechModel (UniSpeech model)
• unispeech-sat — UniSpeechSatModel (UniSpeechSat model)
• univnet — UnivNetModel (UnivNet model)
• van — VanModel (VAN model)
• vaultgemma — VaultGemmaModel (VaultGemma model)
• video_llava — VideoLlavaModel (VideoLlava model)
• videomae — VideoMAEModel (VideoMAE model)
• vilt — ViltModel (ViLT model)
• vipllava — VipLlavaModel (VipLlava model)
• vision-text-dual-encoder — VisionTextDualEncoderModel (VisionTextDualEncoder model)
• visual_bert — VisualBertModel (VisualBERT model)
• vit — ViTModel (ViT model)
• vit_hybrid — ViTHybridModel (ViT Hybrid model)
• vit_mae — ViTMAEModel (ViTMAE model)
• vit_msn — ViTMSNModel (ViTMSN model)
• vitdet — VitDetModel (VitDet model)
• vits — VitsModel (VITS model)
• vivit — VivitModel (ViViT model)
• vjepa2 — VJEPA2Model (VJEPA2Model model)
• voxtral — VoxtralForConditionalGeneration (Voxtral model)
• voxtral_encoder — VoxtralEncoder (Voxtral Encoder model)
• wav2vec2 — Wav2Vec2Model (Wav2Vec2 model)
• wav2vec2-bert — Wav2Vec2BertModel (Wav2Vec2-BERT model)
• wav2vec2-conformer — Wav2Vec2ConformerModel (Wav2Vec2-Conformer model)
• wavlm — WavLMModel (WavLM model)
• whisper — WhisperModel (Whisper model)
• xclip — XCLIPModel (X-CLIP model)
• xcodec — XcodecModel (X-CODEC model)
• xglm — XGLMModel (XGLM model)
• xlm — XLMModel (XLM model)
• xlm-prophetnet — XLMProphetNetModel (XLM-ProphetNet model)
• xlm-roberta — XLMRobertaModel (XLM-RoBERTa model)
• xlm-roberta-xl — XLMRobertaXLModel (XLM-RoBERTa-XL model)
• xlnet — XLNetModel (XLNet model)
• xlstm — xLSTMModel (xLSTM model)
• xmod — XmodModel (X-MOD model)
• yolos — YolosModel (YOLOS model)
• yoso — YosoModel (YOSO model)
• zamba — ZambaModel (Zamba model)
• zamba2 — Zamba2Model (Zamba2 model)

The model is set in evaluation mode by default using model.eval() (so for instance, dropout modules are deactivated). To train the model, you should first set it back in training mode with model.train()

>>> from transformers import AutoConfig, AutoModel

>>> # Download model and configuration from huggingface.co and cache.
>>> model = AutoModel.from_pretrained("google-bert/bert-base-cased")

>>> # Update configuration during loading
>>> model = AutoModel.from_pretrained("google-bert/bert-base-cased", output_attentions=True)
>>> model.config.output_attentions
True

>>> # Loading from a TF checkpoint file instead of a PyTorch model (slower)
>>> config = AutoConfig.from_pretrained("./tf_model/bert_tf_model_config.json")
>>> model = AutoModel.from_pretrained(
...     "./tf_model/bert_tf_checkpoint.ckpt.index", from_tf=True, config=config
... )