Transformers documentation

Transformers

to get started

()

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

The configuration class to instantiate is selected based on themodel_type property of the config object thatis loaded, or when it’s missing, by falling back to using pattern matching onpretrained_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)
• cwm —CwmConfig (Code World Model (CWM) 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_moe —Lfm2MoeConfig (Lfm2Moe 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_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_llama_3 —VideoLlama3Config (VideoLlama3 model)
• video_llama_3_vision —VideoLlama3VisionConfig (VideoLlama3Vision 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 transformersimport 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_attentionsTrue>>>config, unused_kwargs = AutoConfig.from_pretrained(..."google-bert/bert-base-uncased", output_attentions=True, foo=False, return_unused_kwargs=True...)>>>config.output_attentionsTrue>>>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 themodel_type property of the config object (eitherpassed as an argument or loaded frompretrained_model_name_or_path if possible), or when it’s missing, byfalling back to using pattern matching onpretrained_model_name_or_path:

• aimv2 —CLIPTokenizer orCLIPTokenizerFast (AIMv2 model)
• albert —AlbertTokenizer orAlbertTokenizerFast (ALBERT model)
• align —BertTokenizer orBertTokenizerFast (ALIGN model)
• arcee —LlamaTokenizer orLlamaTokenizerFast (Arcee model)
• aria —LlamaTokenizer orLlamaTokenizerFast (Aria model)
• aya_vision —CohereTokenizerFast (AyaVision model)
• bark —BertTokenizer orBertTokenizerFast (Bark model)
• bart —BartTokenizer orBartTokenizerFast (BART model)
• barthez —BarthezTokenizer orBarthezTokenizerFast (BARThez model)
• bartpho —BartphoTokenizer (BARTpho model)
• bert —BertTokenizer orBertTokenizerFast (BERT model)
• bert-generation —BertGenerationTokenizer (Bert Generation model)
• bert-japanese —BertJapaneseTokenizer (BertJapanese model)
• bertweet —BertweetTokenizer (BERTweet model)
• big_bird —BigBirdTokenizer orBigBirdTokenizerFast (BigBird model)
• bigbird_pegasus —PegasusTokenizer orPegasusTokenizerFast (BigBird-Pegasus model)
• biogpt —BioGptTokenizer (BioGpt model)
• bitnet —PreTrainedTokenizerFast (BitNet model)
• blenderbot —BlenderbotTokenizer orBlenderbotTokenizerFast (Blenderbot model)
• blenderbot-small —BlenderbotSmallTokenizer (BlenderbotSmall model)
• blip —BertTokenizer orBertTokenizerFast (BLIP model)
• blip-2 —GPT2Tokenizer orGPT2TokenizerFast (BLIP-2 model)
• bloom —BloomTokenizerFast (BLOOM model)
• blt —PreTrainedTokenizerFast (Blt model)
• bridgetower —RobertaTokenizer orRobertaTokenizerFast (BridgeTower model)
• bros —BertTokenizer orBertTokenizerFast (BROS model)
• byt5 —ByT5Tokenizer (ByT5 model)
• camembert —CamembertTokenizer orCamembertTokenizerFast (CamemBERT model)
• canine —CanineTokenizer (CANINE model)
• chameleon —LlamaTokenizer orLlamaTokenizerFast (Chameleon model)
• chinese_clip —BertTokenizer orBertTokenizerFast (Chinese-CLIP model)
• clap —RobertaTokenizer orRobertaTokenizerFast (CLAP model)
• clip —CLIPTokenizer orCLIPTokenizerFast (CLIP model)
• clipseg —CLIPTokenizer orCLIPTokenizerFast (CLIPSeg model)
• clvp —ClvpTokenizer (CLVP model)
• code_llama —CodeLlamaTokenizer orCodeLlamaTokenizerFast (CodeLlama model)
• codegen —CodeGenTokenizer orCodeGenTokenizerFast (CodeGen model)
• cohere —CohereTokenizerFast (Cohere model)
• cohere2 —CohereTokenizerFast (Cohere2 model)
• colpali —LlamaTokenizer orLlamaTokenizerFast (ColPali model)
• colqwen2 —Qwen2Tokenizer orQwen2TokenizerFast (ColQwen2 model)
• convbert —ConvBertTokenizer orConvBertTokenizerFast (ConvBERT model)
• cpm —CpmTokenizer orCpmTokenizerFast (CPM model)
• cpmant —CpmAntTokenizer (CPM-Ant model)
• csm —PreTrainedTokenizerFast (CSM model)
• ctrl —CTRLTokenizer (CTRL model)
• cwm —LlamaTokenizer orLlamaTokenizerFast (Code World Model (CWM) model)
• data2vec-audio —Wav2Vec2CTCTokenizer (Data2VecAudio model)
• data2vec-text —RobertaTokenizer orRobertaTokenizerFast (Data2VecText model)
• dbrx —GPT2Tokenizer orGPT2TokenizerFast (DBRX model)
• deberta —DebertaTokenizer orDebertaTokenizerFast (DeBERTa model)
• deberta-v2 —DebertaV2Tokenizer orDebertaV2TokenizerFast (DeBERTa-v2 model)
• deepseek_v2 —LlamaTokenizer orLlamaTokenizerFast (DeepSeek-V2 model)
• deepseek_v3 —LlamaTokenizer orLlamaTokenizerFast (DeepSeek-V3 model)
• deepseek_vl —LlamaTokenizer orLlamaTokenizerFast (DeepseekVL model)
• deepseek_vl_hybrid —LlamaTokenizer orLlamaTokenizerFast (DeepseekVLHybrid model)
• dia —DiaTokenizer (Dia model)
• diffllama —LlamaTokenizer orLlamaTokenizerFast (DiffLlama model)
• distilbert —DistilBertTokenizer orDistilBertTokenizerFast (DistilBERT model)
• dpr —DPRQuestionEncoderTokenizer orDPRQuestionEncoderTokenizerFast (DPR model)
• electra —ElectraTokenizer orElectraTokenizerFast (ELECTRA model)
• emu3 —GPT2Tokenizer orGPT2TokenizerFast (Emu3 model)
• ernie —BertTokenizer orBertTokenizerFast (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 orGPT2TokenizerFast (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 orFNetTokenizerFast (FNet model)
• fsmt —FSMTTokenizer (FairSeq Machine-Translation model)
• funnel —FunnelTokenizer orFunnelTokenizerFast (Funnel Transformer model)
• gemma —GemmaTokenizer orGemmaTokenizerFast (Gemma model)
• gemma2 —GemmaTokenizer orGemmaTokenizerFast (Gemma2 model)
• gemma3 —GemmaTokenizer orGemmaTokenizerFast (Gemma3ForConditionalGeneration model)
• gemma3_text —GemmaTokenizer orGemmaTokenizerFast (Gemma3ForCausalLM model)
• gemma3n —GemmaTokenizer orGemmaTokenizerFast (Gemma3nForConditionalGeneration model)
• gemma3n_text —GemmaTokenizer orGemmaTokenizerFast (Gemma3nForCausalLM model)
• git —BertTokenizer orBertTokenizerFast (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 orGPT2TokenizerFast (OpenAI GPT-2 model)
• gpt_bigcode —GPT2Tokenizer orGPT2TokenizerFast (GPTBigCode model)
• gpt_neo —GPT2Tokenizer orGPT2TokenizerFast (GPT Neo model)
• gpt_neox —GPTNeoXTokenizerFast (GPT NeoX model)
• gpt_neox_japanese —GPTNeoXJapaneseTokenizer (GPT NeoX Japanese model)
• gpt_oss —PreTrainedTokenizerFast (GptOss model)
• gptj —GPT2Tokenizer orGPT2TokenizerFast (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 orBertTokenizerFast (Grounding DINO model)
• groupvit —CLIPTokenizer orCLIPTokenizerFast (GroupViT model)
• helium —PreTrainedTokenizerFast (Helium model)
• herbert —HerbertTokenizer orHerbertTokenizerFast (HerBERT model)
• hubert —Wav2Vec2CTCTokenizer (Hubert model)
• ibert —RobertaTokenizer orRobertaTokenizerFast (I-BERT model)
• idefics —LlamaTokenizerFast (IDEFICS model)
• idefics2 —LlamaTokenizer orLlamaTokenizerFast (Idefics2 model)
• idefics3 —LlamaTokenizer orLlamaTokenizerFast (Idefics3 model)
• instructblip —GPT2Tokenizer orGPT2TokenizerFast (InstructBLIP model)
• instructblipvideo —GPT2Tokenizer orGPT2TokenizerFast (InstructBlipVideo model)
• internvl —Qwen2Tokenizer orQwen2TokenizerFast (InternVL model)
• jamba —LlamaTokenizer orLlamaTokenizerFast (Jamba model)
• janus —LlamaTokenizerFast (Janus model)
• jetmoe —LlamaTokenizer orLlamaTokenizerFast (JetMoe model)
• jukebox —JukeboxTokenizer (Jukebox model)
• kosmos-2 —XLMRobertaTokenizer orXLMRobertaTokenizerFast (KOSMOS-2 model)
• kosmos-2.5 —PreTrainedTokenizerFast (KOSMOS-2.5 model)
• layoutlm —LayoutLMTokenizer orLayoutLMTokenizerFast (LayoutLM model)
• layoutlmv2 —LayoutLMv2Tokenizer orLayoutLMv2TokenizerFast (LayoutLMv2 model)
• layoutlmv3 —LayoutLMv3Tokenizer orLayoutLMv3TokenizerFast (LayoutLMv3 model)
• layoutxlm —LayoutXLMTokenizer orLayoutXLMTokenizerFast (LayoutXLM model)
• led —LEDTokenizer orLEDTokenizerFast (LED model)
• lilt —LayoutLMv3Tokenizer orLayoutLMv3TokenizerFast (LiLT model)
• llama —LlamaTokenizer orLlamaTokenizerFast (LLaMA model)
• llama4 —LlamaTokenizer orLlamaTokenizerFast (Llama4 model)
• llama4_text —LlamaTokenizer orLlamaTokenizerFast (Llama4ForCausalLM model)
• llava —LlamaTokenizer orLlamaTokenizerFast (LLaVa model)
• llava_next —LlamaTokenizer orLlamaTokenizerFast (LLaVA-NeXT model)
• llava_next_video —LlamaTokenizer orLlamaTokenizerFast (LLaVa-NeXT-Video model)
• llava_onevision —LlamaTokenizer orLlamaTokenizerFast (LLaVA-Onevision model)
• longformer —LongformerTokenizer orLongformerTokenizerFast (Longformer model)
• longt5 —T5Tokenizer orT5TokenizerFast (LongT5 model)
• luke —LukeTokenizer (LUKE model)
• lxmert —LxmertTokenizer orLxmertTokenizerFast (LXMERT model)
• m2m_100 —M2M100Tokenizer (M2M100 model)
• mamba —GPTNeoXTokenizerFast (Mamba model)
• mamba2 —GPTNeoXTokenizerFast (mamba2 model)
• marian —MarianTokenizer (Marian model)
• mbart —MBartTokenizer orMBartTokenizerFast (mBART model)
• mbart50 —MBart50Tokenizer orMBart50TokenizerFast (mBART-50 model)
• mega —RobertaTokenizer orRobertaTokenizerFast (MEGA model)
• megatron-bert —BertTokenizer orBertTokenizerFast (Megatron-BERT model)
• metaclip_2 —XLMRobertaTokenizer orXLMRobertaTokenizerFast (MetaCLIP 2 model)
• mgp-str —MgpstrTokenizer (MGP-STR model)
• minimax —GPT2Tokenizer orGPT2TokenizerFast (MiniMax model)
• mistral —MistralCommonTokenizer (Mistral model)
• mixtral —MistralCommonTokenizer (Mixtral model)
• mllama —LlamaTokenizer orLlamaTokenizerFast (Mllama model)
• mluke —MLukeTokenizer (mLUKE model)
• mm-grounding-dino —BertTokenizer orBertTokenizerFast (MM Grounding DINO model)
• mobilebert —MobileBertTokenizer orMobileBertTokenizerFast (MobileBERT model)
• modernbert —PreTrainedTokenizerFast (ModernBERT model)
• moonshine —PreTrainedTokenizerFast (Moonshine model)
• moshi —PreTrainedTokenizerFast (Moshi model)
• mpnet —MPNetTokenizer orMPNetTokenizerFast (MPNet model)
• mpt —GPTNeoXTokenizerFast (MPT model)
• mra —RobertaTokenizer orRobertaTokenizerFast (MRA model)
• mt5 —MT5Tokenizer orMT5TokenizerFast (MT5 model)
• musicgen —T5Tokenizer orT5TokenizerFast (MusicGen model)
• musicgen_melody —T5Tokenizer orT5TokenizerFast (MusicGen Melody model)
• mvp —MvpTokenizer orMvpTokenizerFast (MVP model)
• myt5 —MyT5Tokenizer (myt5 model)
• nemotron —PreTrainedTokenizerFast (Nemotron model)
• nezha —BertTokenizer orBertTokenizerFast (Nezha model)
• nllb —NllbTokenizer orNllbTokenizerFast (NLLB model)
• nllb-moe —NllbTokenizer orNllbTokenizerFast (NLLB-MOE model)
• nystromformer —AlbertTokenizer orAlbertTokenizerFast (Nyströmformer model)
• olmo —GPTNeoXTokenizerFast (OLMo model)
• olmo2 —GPTNeoXTokenizerFast (OLMo2 model)
• olmo3 —GPT2TokenizerFast (Olmo3 model)
• olmoe —GPTNeoXTokenizerFast (OLMoE model)
• omdet-turbo —CLIPTokenizer orCLIPTokenizerFast (OmDet-Turbo model)
• oneformer —CLIPTokenizer orCLIPTokenizerFast (OneFormer model)
• openai-gpt —OpenAIGPTTokenizer orOpenAIGPTTokenizerFast (OpenAI GPT model)
• opt —GPT2Tokenizer orGPT2TokenizerFast (OPT model)
• owlv2 —CLIPTokenizer orCLIPTokenizerFast (OWLv2 model)
• owlvit —CLIPTokenizer orCLIPTokenizerFast (OWL-ViT model)
• paligemma —LlamaTokenizer orLlamaTokenizerFast (PaliGemma model)
• parakeet —ParakeetTokenizerFast (Parakeet model)
• pegasus —PegasusTokenizer orPegasusTokenizerFast (Pegasus model)
• pegasus_x —PegasusTokenizer orPegasusTokenizerFast (PEGASUS-X model)
• perceiver —PerceiverTokenizer (Perceiver model)
• persimmon —LlamaTokenizer orLlamaTokenizerFast (Persimmon model)
• phi —CodeGenTokenizer orCodeGenTokenizerFast (Phi model)
• phi3 —LlamaTokenizer orLlamaTokenizerFast (Phi3 model)
• phimoe —LlamaTokenizer orLlamaTokenizerFast (Phimoe model)
• phobert —PhobertTokenizer (PhoBERT model)
• pix2struct —T5Tokenizer orT5TokenizerFast (Pix2Struct model)
• pixtral —MistralCommonTokenizer (Pixtral model)
• plbart —PLBartTokenizer (PLBart model)
• prophetnet —ProphetNetTokenizer (ProphetNet model)
• qdqbert —BertTokenizer orBertTokenizerFast (QDQBert model)
• qwen2 —Qwen2Tokenizer orQwen2TokenizerFast (Qwen2 model)
• qwen2_5_omni —Qwen2Tokenizer orQwen2TokenizerFast (Qwen2_5Omni model)
• qwen2_5_vl —Qwen2Tokenizer orQwen2TokenizerFast (Qwen2_5_VL model)
• qwen2_audio —Qwen2Tokenizer orQwen2TokenizerFast (Qwen2Audio model)
• qwen2_moe —Qwen2Tokenizer orQwen2TokenizerFast (Qwen2MoE model)
• qwen2_vl —Qwen2Tokenizer orQwen2TokenizerFast (Qwen2VL model)
• qwen3 —Qwen2Tokenizer orQwen2TokenizerFast (Qwen3 model)
• qwen3_moe —Qwen2Tokenizer orQwen2TokenizerFast (Qwen3MoE model)
• qwen3_next —Qwen2Tokenizer orQwen2TokenizerFast (Qwen3Next model)
• qwen3_omni_moe —Qwen2Tokenizer orQwen2TokenizerFast (Qwen3OmniMoE model)
• qwen3_vl —Qwen2Tokenizer orQwen2TokenizerFast (Qwen3VL model)
• qwen3_vl_moe —Qwen2Tokenizer orQwen2TokenizerFast (Qwen3VLMoe model)
• rag —RagTokenizer (RAG model)
• realm —RealmTokenizer orRealmTokenizerFast (REALM model)
• recurrent_gemma —GemmaTokenizer orGemmaTokenizerFast (RecurrentGemma model)
• reformer —ReformerTokenizer orReformerTokenizerFast (Reformer model)
• rembert —RemBertTokenizer orRemBertTokenizerFast (RemBERT model)
• retribert —RetriBertTokenizer orRetriBertTokenizerFast (RetriBERT model)
• roberta —RobertaTokenizer orRobertaTokenizerFast (RoBERTa model)
• roberta-prelayernorm —RobertaTokenizer orRobertaTokenizerFast (RoBERTa-PreLayerNorm model)
• roc_bert —RoCBertTokenizer (RoCBert model)
• roformer —RoFormerTokenizer orRoFormerTokenizerFast (RoFormer model)
• rwkv —GPTNeoXTokenizerFast (RWKV model)
• seamless_m4t —SeamlessM4TTokenizer orSeamlessM4TTokenizerFast (SeamlessM4T model)
• seamless_m4t_v2 —SeamlessM4TTokenizer orSeamlessM4TTokenizerFast (SeamlessM4Tv2 model)
• shieldgemma2 —GemmaTokenizer orGemmaTokenizerFast (Shieldgemma2 model)
• siglip —SiglipTokenizer (SigLIP model)
• siglip2 —GemmaTokenizer orGemmaTokenizerFast (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 orSplinterTokenizerFast (Splinter model)
• squeezebert —SqueezeBertTokenizer orSqueezeBertTokenizerFast (SqueezeBERT model)
• stablelm —GPTNeoXTokenizerFast (StableLm model)
• starcoder2 —GPT2Tokenizer orGPT2TokenizerFast (Starcoder2 model)
• switch_transformers —T5Tokenizer orT5TokenizerFast (SwitchTransformers model)
• t5 —T5Tokenizer orT5TokenizerFast (T5 model)
• t5gemma —GemmaTokenizer orGemmaTokenizerFast (T5Gemma model)
• tapas —TapasTokenizer (TAPAS model)
• tapex —TapexTokenizer (TAPEX model)
• transfo-xl —TransfoXLTokenizer (Transformer-XL model)
• tvp —BertTokenizer orBertTokenizerFast (TVP model)
• udop —UdopTokenizer orUdopTokenizerFast (UDOP model)
• umt5 —T5Tokenizer orT5TokenizerFast (UMT5 model)
• video_llava —LlamaTokenizer orLlamaTokenizerFast (VideoLlava model)
• vilt —BertTokenizer orBertTokenizerFast (ViLT model)
• vipllava —LlamaTokenizer orLlamaTokenizerFast (VipLlava model)
• visual_bert —BertTokenizer orBertTokenizerFast (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 orWhisperTokenizerFast (Whisper model)
• xclip —CLIPTokenizer orCLIPTokenizerFast (X-CLIP model)
• xglm —XGLMTokenizer orXGLMTokenizerFast (XGLM model)
• xlm —XLMTokenizer (XLM model)
• xlm-prophetnet —XLMProphetNetTokenizer (XLM-ProphetNet model)
• xlm-roberta —XLMRobertaTokenizer orXLMRobertaTokenizerFast (XLM-RoBERTa model)
• xlm-roberta-xl —XLMRobertaTokenizer orXLMRobertaTokenizerFast (XLM-RoBERTa-XL model)
• xlnet —XLNetTokenizer orXLNetTokenizerFast (XLNet model)
• xlstm —GPTNeoXTokenizerFast (xLSTM model)
• xmod —XLMRobertaTokenizer orXLMRobertaTokenizerFast (X-MOD model)
• yoso —AlbertTokenizer orAlbertTokenizerFast (YOSO model)
• zamba —LlamaTokenizer orLlamaTokenizerFast (Zamba model)
• zamba2 —LlamaTokenizer orLlamaTokenizerFast (Zamba2 model)

>>>from transformersimport 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 themodel_type property of the config object(either passed as an argument or loaded frompretrained_model_name_or_path if possible), or when it’smissing, by falling back to using pattern matching onpretrained_model_name_or_path:

• audio-spectrogram-transformer —ASTFeatureExtractor (Audio Spectrogram Transformer model)
• clap —ClapFeatureExtractor (CLAP model)
• clvp —ClvpFeatureExtractor (CLVP model)
• dac —DacFeatureExtractor (DAC model)
• data2vec-audio —Wav2Vec2FeatureExtractor (Data2VecAudio model)
• dia —DiaFeatureExtractor (Dia model)
• encodec —EncodecFeatureExtractor (EnCodec model)
• gemma3n —Gemma3nAudioFeatureExtractor (Gemma3nForConditionalGeneration model)
• granite_speech —GraniteSpeechFeatureExtractor (GraniteSpeech model)
• hubert —Wav2Vec2FeatureExtractor (Hubert model)
• kyutai_speech_to_text —KyutaiSpeechToTextFeatureExtractor (KyutaiSpeechToText model)
• mctct —MCTCTFeatureExtractor (M-CTC-T model)
• mimi —EncodecFeatureExtractor (Mimi model)
• moonshine —Wav2Vec2FeatureExtractor (Moonshine model)
• moshi —EncodecFeatureExtractor (Moshi model)
• parakeet_ctc —ParakeetFeatureExtractor (Parakeet model)
• parakeet_encoder —ParakeetFeatureExtractor (ParakeetEncoder model)
• phi4_multimodal —Phi4MultimodalFeatureExtractor (Phi4Multimodal model)
• pop2piano —Pop2PianoFeatureExtractor (Pop2Piano model)
• seamless_m4t —SeamlessM4TFeatureExtractor (SeamlessM4T model)
• seamless_m4t_v2 —SeamlessM4TFeatureExtractor (SeamlessM4Tv2 model)
• sew —Wav2Vec2FeatureExtractor (SEW model)
• sew-d —Wav2Vec2FeatureExtractor (SEW-D model)
• speech_to_text —Speech2TextFeatureExtractor (Speech2Text model)
• speecht5 —SpeechT5FeatureExtractor (SpeechT5 model)
• unispeech —Wav2Vec2FeatureExtractor (UniSpeech model)
• unispeech-sat —Wav2Vec2FeatureExtractor (UniSpeechSat model)
• univnet —UnivNetFeatureExtractor (UnivNet 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)
• xcodec —DacFeatureExtractor (X-CODEC model)

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

>>>from transformersimport 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 themodel_type property of the config object(either passed as an argument or loaded frompretrained_model_name_or_path if possible), or when it’smissing, by falling back to using pattern matching onpretrained_model_name_or_path:

• aimv2 —CLIPImageProcessor orCLIPImageProcessorFast (AIMv2 model)
• aimv2_vision_model —CLIPImageProcessor orCLIPImageProcessorFast (Aimv2VisionModel model)
• align —EfficientNetImageProcessor orEfficientNetImageProcessorFast (ALIGN model)
• aria —AriaImageProcessor (Aria model)
• beit —BeitImageProcessor orBeitImageProcessorFast (BEiT model)
• bit —BitImageProcessor orBitImageProcessorFast (BiT model)
• blip —BlipImageProcessor orBlipImageProcessorFast (BLIP model)
• blip-2 —BlipImageProcessor orBlipImageProcessorFast (BLIP-2 model)
• bridgetower —BridgeTowerImageProcessor orBridgeTowerImageProcessorFast (BridgeTower model)
• chameleon —ChameleonImageProcessor orChameleonImageProcessorFast (Chameleon model)
• chinese_clip —ChineseCLIPImageProcessor orChineseCLIPImageProcessorFast (Chinese-CLIP model)
• clip —CLIPImageProcessor orCLIPImageProcessorFast (CLIP model)
• clipseg —ViTImageProcessor orViTImageProcessorFast (CLIPSeg model)
• cohere2_vision —Cohere2VisionImageProcessorFast (Cohere2Vision model)
• conditional_detr —ConditionalDetrImageProcessor orConditionalDetrImageProcessorFast (Conditional DETR model)
• convnext —ConvNextImageProcessor orConvNextImageProcessorFast (ConvNeXT model)
• convnextv2 —ConvNextImageProcessor orConvNextImageProcessorFast (ConvNeXTV2 model)
• cvt —ConvNextImageProcessor orConvNextImageProcessorFast (CvT model)
• data2vec-vision —BeitImageProcessor orBeitImageProcessorFast (Data2VecVision model)
• deepseek_vl —DeepseekVLImageProcessor orDeepseekVLImageProcessorFast (DeepseekVL model)
• deepseek_vl_hybrid —DeepseekVLHybridImageProcessor orDeepseekVLHybridImageProcessorFast (DeepseekVLHybrid model)
• deformable_detr —DeformableDetrImageProcessor orDeformableDetrImageProcessorFast (Deformable DETR model)
• deit —DeiTImageProcessor orDeiTImageProcessorFast (DeiT model)
• depth_anything —DPTImageProcessor orDPTImageProcessorFast (Depth Anything model)
• depth_pro —DepthProImageProcessor orDepthProImageProcessorFast (DepthPro model)
• deta —DetaImageProcessor (DETA model)
• detr —DetrImageProcessor orDetrImageProcessorFast (DETR model)
• dinat —ViTImageProcessor orViTImageProcessorFast (DiNAT model)
• dinov2 —BitImageProcessor orBitImageProcessorFast (DINOv2 model)
• dinov3_vit —DINOv3ViTImageProcessorFast (DINOv3 ViT model)
• donut-swin —DonutImageProcessor orDonutImageProcessorFast (DonutSwin model)
• dpt —DPTImageProcessor orDPTImageProcessorFast (DPT model)
• edgetam —Sam2ImageProcessorFast (EdgeTAM model)
• efficientformer —EfficientFormerImageProcessor (EfficientFormer model)
• efficientloftr —EfficientLoFTRImageProcessor orEfficientLoFTRImageProcessorFast (EfficientLoFTR model)
• efficientnet —EfficientNetImageProcessor orEfficientNetImageProcessorFast (EfficientNet model)
• eomt —EomtImageProcessor orEomtImageProcessorFast (EoMT model)
• flava —FlavaImageProcessor orFlavaImageProcessorFast (FLAVA model)
• focalnet —BitImageProcessor orBitImageProcessorFast (FocalNet model)
• fuyu —FuyuImageProcessor orFuyuImageProcessorFast (Fuyu model)
• gemma3 —Gemma3ImageProcessor orGemma3ImageProcessorFast (Gemma3ForConditionalGeneration model)
• gemma3n —SiglipImageProcessor orSiglipImageProcessorFast (Gemma3nForConditionalGeneration model)
• git —CLIPImageProcessor orCLIPImageProcessorFast (GIT model)
• glm4v —Glm4vImageProcessor orGlm4vImageProcessorFast (GLM4V model)
• glpn —GLPNImageProcessor orGLPNImageProcessorFast (GLPN model)
• got_ocr2 —GotOcr2ImageProcessor orGotOcr2ImageProcessorFast (GOT-OCR2 model)
• grounding-dino —GroundingDinoImageProcessor orGroundingDinoImageProcessorFast (Grounding DINO model)
• groupvit —CLIPImageProcessor orCLIPImageProcessorFast (GroupViT model)
• hiera —BitImageProcessor orBitImageProcessorFast (Hiera model)
• idefics —IdeficsImageProcessor (IDEFICS model)
• idefics2 —Idefics2ImageProcessor orIdefics2ImageProcessorFast (Idefics2 model)
• idefics3 —Idefics3ImageProcessor orIdefics3ImageProcessorFast (Idefics3 model)
• ijepa —ViTImageProcessor orViTImageProcessorFast (I-JEPA model)
• imagegpt —ImageGPTImageProcessor orImageGPTImageProcessorFast (ImageGPT model)
• instructblip —BlipImageProcessor orBlipImageProcessorFast (InstructBLIP model)
• janus —JanusImageProcessor orJanusImageProcessorFast (Janus model)
• kosmos-2 —CLIPImageProcessor orCLIPImageProcessorFast (KOSMOS-2 model)
• kosmos-2.5 —Kosmos2_5ImageProcessor orKosmos2_5ImageProcessorFast (KOSMOS-2.5 model)
• layoutlmv2 —LayoutLMv2ImageProcessor orLayoutLMv2ImageProcessorFast (LayoutLMv2 model)
• layoutlmv3 —LayoutLMv3ImageProcessor orLayoutLMv3ImageProcessorFast (LayoutLMv3 model)
• levit —LevitImageProcessor orLevitImageProcessorFast (LeViT model)
• lfm2_vl —Lfm2VlImageProcessorFast (Lfm2Vl model)
• lightglue —LightGlueImageProcessor orLightGlueImageProcessorFast (LightGlue model)
• llama4 —Llama4ImageProcessor orLlama4ImageProcessorFast (Llama4 model)
• llava —LlavaImageProcessor orLlavaImageProcessorFast (LLaVa model)
• llava_next —LlavaNextImageProcessor orLlavaNextImageProcessorFast (LLaVA-NeXT model)
• llava_next_video —LlavaNextImageProcessor orLlavaNextImageProcessorFast (LLaVa-NeXT-Video model)
• llava_onevision —LlavaOnevisionImageProcessor orLlavaOnevisionImageProcessorFast (LLaVA-Onevision model)
• mask2former —Mask2FormerImageProcessor orMask2FormerImageProcessorFast (Mask2Former model)
• maskformer —MaskFormerImageProcessor orMaskFormerImageProcessorFast (MaskFormer model)
• metaclip_2 —CLIPImageProcessor orCLIPImageProcessorFast (MetaCLIP 2 model)
• mgp-str —ViTImageProcessor orViTImageProcessorFast (MGP-STR model)
• mistral3 —PixtralImageProcessor orPixtralImageProcessorFast (Mistral3 model)
• mlcd —CLIPImageProcessor orCLIPImageProcessorFast (MLCD model)
• mllama —MllamaImageProcessor orMllamaImageProcessorFast (Mllama model)
• mm-grounding-dino —GroundingDinoImageProcessor orGroundingDinoImageProcessorFast (MM Grounding DINO model)
• mobilenet_v1 —MobileNetV1ImageProcessor orMobileNetV1ImageProcessorFast (MobileNetV1 model)
• mobilenet_v2 —MobileNetV2ImageProcessor orMobileNetV2ImageProcessorFast (MobileNetV2 model)
• mobilevit —MobileViTImageProcessor orMobileViTImageProcessorFast (MobileViT model)
• mobilevitv2 —MobileViTImageProcessor orMobileViTImageProcessorFast (MobileViTV2 model)
• nat —ViTImageProcessor orViTImageProcessorFast (NAT model)
• nougat —NougatImageProcessor orNougatImageProcessorFast (Nougat model)
• oneformer —OneFormerImageProcessor orOneFormerImageProcessorFast (OneFormer model)
• ovis2 —Ovis2ImageProcessor orOvis2ImageProcessorFast (Ovis2 model)
• owlv2 —Owlv2ImageProcessor orOwlv2ImageProcessorFast (OWLv2 model)
• owlvit —OwlViTImageProcessor orOwlViTImageProcessorFast (OWL-ViT model)
• paligemma —SiglipImageProcessor orSiglipImageProcessorFast (PaliGemma model)
• perceiver —PerceiverImageProcessor orPerceiverImageProcessorFast (Perceiver model)
• perception_lm —PerceptionLMImageProcessorFast (PerceptionLM model)
• phi4_multimodal —Phi4MultimodalImageProcessorFast (Phi4Multimodal model)
• pix2struct —Pix2StructImageProcessor (Pix2Struct model)
• pixtral —PixtralImageProcessor orPixtralImageProcessorFast (Pixtral model)
• poolformer —PoolFormerImageProcessor orPoolFormerImageProcessorFast (PoolFormer model)
• prompt_depth_anything —PromptDepthAnythingImageProcessor orPromptDepthAnythingImageProcessorFast (PromptDepthAnything model)
• pvt —PvtImageProcessor orPvtImageProcessorFast (PVT model)
• pvt_v2 —PvtImageProcessor orPvtImageProcessorFast (PVTv2 model)
• qwen2_5_vl —Qwen2VLImageProcessor orQwen2VLImageProcessorFast (Qwen2_5_VL model)
• qwen2_vl —Qwen2VLImageProcessor orQwen2VLImageProcessorFast (Qwen2VL model)
• qwen3_vl —Qwen2VLImageProcessor orQwen2VLImageProcessorFast (Qwen3VL model)
• regnet —ConvNextImageProcessor orConvNextImageProcessorFast (RegNet model)
• resnet —ConvNextImageProcessor orConvNextImageProcessorFast (ResNet model)
• rt_detr —RTDetrImageProcessor orRTDetrImageProcessorFast (RT-DETR model)
• sam —SamImageProcessor orSamImageProcessorFast (SAM model)
• sam2 —Sam2ImageProcessorFast (SAM2 model)
• sam_hq —SamImageProcessor orSamImageProcessorFast (SAM-HQ model)
• segformer —SegformerImageProcessor orSegformerImageProcessorFast (SegFormer model)
• seggpt —SegGptImageProcessor (SegGPT model)
• shieldgemma2 —Gemma3ImageProcessor orGemma3ImageProcessorFast (Shieldgemma2 model)
• siglip —SiglipImageProcessor orSiglipImageProcessorFast (SigLIP model)
• siglip2 —Siglip2ImageProcessor orSiglip2ImageProcessorFast (SigLIP2 model)
• smolvlm —SmolVLMImageProcessor orSmolVLMImageProcessorFast (SmolVLM model)
• superglue —SuperGlueImageProcessor orSuperGlueImageProcessorFast (SuperGlue model)
• superpoint —SuperPointImageProcessor orSuperPointImageProcessorFast (SuperPoint model)
• swiftformer —ViTImageProcessor orViTImageProcessorFast (SwiftFormer model)
• swin —ViTImageProcessor orViTImageProcessorFast (Swin Transformer model)
• swin2sr —Swin2SRImageProcessor orSwin2SRImageProcessorFast (Swin2SR model)
• swinv2 —ViTImageProcessor orViTImageProcessorFast (Swin Transformer V2 model)
• table-transformer —DetrImageProcessor orDetrImageProcessorFast (Table Transformer model)
• textnet —TextNetImageProcessor orTextNetImageProcessorFast (TextNet model)
• timesformer —VideoMAEImageProcessor (TimeSformer model)
• timm_wrapper —TimmWrapperImageProcessor (TimmWrapperModel model)
• tvlt —TvltImageProcessor (TVLT model)
• tvp —TvpImageProcessor orTvpImageProcessorFast (TVP model)
• udop —LayoutLMv3ImageProcessor orLayoutLMv3ImageProcessorFast (UDOP model)
• upernet —SegformerImageProcessor orSegformerImageProcessorFast (UPerNet model)
• van —ConvNextImageProcessor orConvNextImageProcessorFast (VAN model)
• video_llama_3 —VideoLlama3ImageProcessor orVideoLlama3ImageProcessorFast (VideoLlama3 model)
• videomae —VideoMAEImageProcessor (VideoMAE model)
• vilt —ViltImageProcessor orViltImageProcessorFast (ViLT model)
• vipllava —CLIPImageProcessor orCLIPImageProcessorFast (VipLlava model)
• vit —ViTImageProcessor orViTImageProcessorFast (ViT model)
• vit_hybrid —ViTHybridImageProcessor (ViT Hybrid model)
• vit_mae —ViTImageProcessor orViTImageProcessorFast (ViTMAE model)
• vit_msn —ViTImageProcessor orViTImageProcessorFast (ViTMSN model)
• vitmatte —VitMatteImageProcessor orVitMatteImageProcessorFast (ViTMatte model)
• xclip —CLIPImageProcessor orCLIPImageProcessorFast (X-CLIP model)
• yolos —YolosImageProcessor orYolosImageProcessorFast (YOLOS model)
• zoedepth —ZoeDepthImageProcessor orZoeDepthImageProcessorFast (ZoeDepth model)

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

>>>from transformersimport 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 video processor classes of the library from a pretrained model vocabulary.

The video processor class to instantiate is selected based on themodel_type property of the config object(either passed as an argument or loaded frompretrained_model_name_or_path if possible), or when it’smissing, by falling back to using pattern matching onpretrained_model_name_or_path:

• glm4v —Glm4vVideoProcessor (GLM4V model)
• instructblip —InstructBlipVideoVideoProcessor (InstructBLIP model)
• instructblipvideo —InstructBlipVideoVideoProcessor (InstructBlipVideo model)
• internvl —InternVLVideoProcessor (InternVL model)
• llava_next_video —LlavaNextVideoVideoProcessor (LLaVa-NeXT-Video model)
• llava_onevision —LlavaOnevisionVideoProcessor (LLaVA-Onevision model)
• perception_lm —PerceptionLMVideoProcessor (PerceptionLM model)
• qwen2_5_omni —Qwen2VLVideoProcessor (Qwen2_5Omni model)
• qwen2_5_vl —Qwen2VLVideoProcessor (Qwen2_5_VL model)
• qwen2_vl —Qwen2VLVideoProcessor (Qwen2VL model)
• qwen3_omni_moe —Qwen2VLVideoProcessor (Qwen3OmniMoE model)
• qwen3_vl —Qwen3VLVideoProcessor (Qwen3VL model)
• qwen3_vl_moe —Qwen3VLVideoProcessor (Qwen3VLMoe model)
• sam2_video —Sam2VideoVideoProcessor (Sam2VideoModel model)
• smolvlm —SmolVLMVideoProcessor (SmolVLM model)
• video_llava —VideoLlavaVideoProcessor (VideoLlava model)
• videomae —VideoMAEVideoProcessor (VideoMAE model)
• vjepa2 —VJEPA2VideoProcessor (VJEPA2Model model)

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

>>>from transformersimport AutoVideoProcessor>>># Download video processor from huggingface.co and cache.>>>video_processor = AutoVideoProcessor.from_pretrained("llava-hf/llava-onevision-qwen2-0.5b-ov-hf")>>># If video processor files are in a directory (e.g. video processor was saved using *save_pretrained('./test/saved_model/')*)>>># video_processor = AutoVideoProcessor.from_pretrained("./test/saved_model/")

Register a new video 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 themodel_type property of the config object (eitherpassed as an argument or loaded frompretrained_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)

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

>>>from transformersimport 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.

(*args**kwargs)

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

Note:Loading a model from its configuration file doesnot load the model weights. It only affects themodel’s configuration. Usefrom_pretrained() to load the model weights.

>>>from transformersimport 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 themodel_type property of the config object (eitherpassed as an argument or loaded frompretrained_model_name_or_path if possible), or when it’s missing, byfalling back to using pattern matching onpretrained_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)
• cwm —CwmModel (Code World Model (CWM) 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 orFunnelBaseModel (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_moe —Lfm2MoeModel (Lfm2Moe 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_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_llama_3 —VideoLlama3Model (VideoLlama3 model)
• video_llama_3_vision —VideoLlama3VisionModel (VideoLlama3Vision 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 usingmodel.eval() (so for instance, dropout modules aredeactivated). To train the model, you should first set it back in training mode withmodel.train()

>>>from transformersimport 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_attentionsTrue