import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY
@is_pipeline_test
class 					snake_case	(     unittest.TestCase   ):

   """simple docstring"""







   __lowerCAmelCase   						=      MODEL_FOR_MASKED_LM_MAPPING
   __lowerCAmelCase   						=      TF_MODEL_FOR_MASKED_LM_MAPPING





   def 				snake_case__							(    self	):
     super().tearDown()
     # clean-up as much as possible GPU memory occupied by PyTorch
     gc.collect()
     if is_torch_available():
       import torch

       torch.cuda.empty_cache()





   @require_tf
   def 				snake_case__							(    self	):
     __lowercase					=		pipeline(task="fill-mask"					,	model="sshleifer/tiny-distilroberta-base"					,	top_k=2					,	framework="tf"	)
     __lowercase					=		unmasker("My name is <mask>"	)
     self.assertEqual(
         nested_simplify(__snake_case					,	decimals=6	)					,	[
             {"sequence": "My name is grouped", "score": 2.1E-0_5, "token": 3_8015, "token_str": " grouped"},
             {"sequence": "My name is accuser", "score": 2.1E-0_5, "token": 2_5506, "token_str": " accuser"},
         ]					,	)

     __lowercase					=		unmasker("The largest city in France is <mask>"	)
     self.assertEqual(
         nested_simplify(__snake_case					,	decimals=6	)					,	[
             {
                 "sequence": "The largest city in France is grouped",
                 "score": 2.1E-0_5,
                 "token": 3_8015,
                 "token_str": " grouped",
             },
             {
                 "sequence": "The largest city in France is accuser",
                 "score": 2.1E-0_5,
                 "token": 2_5506,
                 "token_str": " accuser",
             },
         ]					,	)

     __lowercase					=		unmasker("My name is <mask>"					,	targets=[" Patrick", " Clara", " Teven"]					,	top_k=3	)
     self.assertEqual(
         nested_simplify(__snake_case					,	decimals=6	)					,	[
             {"sequence": "My name is Clara", "score": 2E-0_5, "token": 1_3606, "token_str": " Clara"},
             {"sequence": "My name is Patrick", "score": 2E-0_5, "token": 3499, "token_str": " Patrick"},
             {"sequence": "My name is Te", "score": 1.9E-0_5, "token": 2941, "token_str": " Te"},
         ]					,	)





   @require_torch
   def 				snake_case__							(    self	):
     __lowercase					=		pipeline(task="fill-mask"					,	model="sshleifer/tiny-distilroberta-base"					,	top_k=2					,	framework="pt"	)

     __lowercase					=		unmasker("My name is <mask>"	)
     self.assertEqual(
         nested_simplify(__snake_case					,	decimals=6	)					,	[
             {"sequence": "My name is Maul", "score": 2.2E-0_5, "token": 3_5676, "token_str": " Maul"},
             {"sequence": "My name isELS", "score": 2.2E-0_5, "token": 1_6416, "token_str": "ELS"},
         ]					,	)

     __lowercase					=		unmasker("The largest city in France is <mask>"	)
     self.assertEqual(
         nested_simplify(__snake_case					,	decimals=6	)					,	[
             {
                 "sequence": "The largest city in France is Maul",
                 "score": 2.2E-0_5,
                 "token": 3_5676,
                 "token_str": " Maul",
             },
             {"sequence": "The largest city in France isELS", "score": 2.2E-0_5, "token": 1_6416, "token_str": "ELS"},
         ]					,	)

     __lowercase					=		unmasker("My name is <mask>"					,	targets=[" Patrick", " Clara", " Teven"]					,	top_k=3	)
     self.assertEqual(
         nested_simplify(__snake_case					,	decimals=6	)					,	[
             {"sequence": "My name is Patrick", "score": 2.1E-0_5, "token": 3499, "token_str": " Patrick"},
             {"sequence": "My name is Te", "score": 2E-0_5, "token": 2941, "token_str": " Te"},
             {"sequence": "My name is Clara", "score": 2E-0_5, "token": 1_3606, "token_str": " Clara"},
         ]					,	)

     __lowercase					=		unmasker("My name is <mask> <mask>"					,	top_k=2	)

     self.assertEqual(
         nested_simplify(__snake_case					,	decimals=6	)					,	[
             [
                 {
                     "score": 2.2E-0_5,
                     "token": 3_5676,
                     "token_str": " Maul",
                     "sequence": "<s>My name is Maul<mask></s>",
                 },
                 {"score": 2.2E-0_5, "token": 1_6416, "token_str": "ELS", "sequence": "<s>My name isELS<mask></s>"},
             ],
             [
                 {
                     "score": 2.2E-0_5,
                     "token": 3_5676,
                     "token_str": " Maul",
                     "sequence": "<s>My name is<mask> Maul</s>",
                 },
                 {"score": 2.2E-0_5, "token": 1_6416, "token_str": "ELS", "sequence": "<s>My name is<mask>ELS</s>"},
             ],
         ]					,	)





   @require_torch_gpu
   def 				snake_case__							(    self	):
     __lowercase					=		pipeline("fill-mask"					,	model="hf-internal-testing/tiny-random-distilbert"					,	device=0					,	framework="pt"	)

     # convert model to fp16
     pipe.model.half()

     __lowercase					=		pipe("Paris is the [MASK] of France."	)
     # We actually don't care about the result, we just want to make sure
     # it works, meaning the float16 tensor got casted back to float32
     # for postprocessing.
     self.assertIsInstance(__snake_case					,	__snake_case	)





   @slow
   @require_torch
   def 				snake_case__							(    self	):
     __lowercase					=		pipeline(task="fill-mask"					,	model="distilroberta-base"					,	top_k=2					,	framework="pt"	)
     self.run_large_test(__snake_case	)





   @slow
   @require_tf
   def 				snake_case__							(    self	):
     __lowercase					=		pipeline(task="fill-mask"					,	model="distilroberta-base"					,	top_k=2					,	framework="tf"	)
     self.run_large_test(__snake_case	)





   def 				snake_case__							(    self					,	lowerCAmelCase_	):
     __lowercase					=		unmasker("My name is <mask>"	)
     self.assertEqual(
         nested_simplify(__snake_case	)					,	[
             {"sequence": "My name is John", "score": 0.0_08, "token": 610, "token_str": " John"},
             {"sequence": "My name is Chris", "score": 0.0_07, "token": 1573, "token_str": " Chris"},
         ]					,	)
     __lowercase					=		unmasker("The largest city in France is <mask>"	)
     self.assertEqual(
         nested_simplify(__snake_case	)					,	[
             {
                 "sequence": "The largest city in France is Paris",
                 "score": 0.2_51,
                 "token": 2201,
                 "token_str": " Paris",
             },
             {
                 "sequence": "The largest city in France is Lyon",
                 "score": 0.2_14,
                 "token": 1_2790,
                 "token_str": " Lyon",
             },
         ]					,	)

     __lowercase					=		unmasker("My name is <mask>"					,	targets=[" Patrick", " Clara", " Teven"]					,	top_k=3	)
     self.assertEqual(
         nested_simplify(__snake_case	)					,	[
             {"sequence": "My name is Patrick", "score": 0.0_05, "token": 3499, "token_str": " Patrick"},
             {"sequence": "My name is Clara", "score": 0.0_00, "token": 1_3606, "token_str": " Clara"},
             {"sequence": "My name is Te", "score": 0.0_00, "token": 2941, "token_str": " Te"},
         ]					,	)





   @require_torch
   def 				snake_case__							(    self	):
     __lowercase					=		pipeline(task="fill-mask"					,	model="sshleifer/tiny-distilroberta-base"					,	framework="pt"	)
     __lowercase					=		None
     __lowercase					=		None
     self.run_pipeline_test(__snake_case					,	[]	)





   @require_tf
   def 				snake_case__							(    self	):
     __lowercase					=		pipeline(task="fill-mask"					,	model="sshleifer/tiny-distilroberta-base"					,	framework="tf"	)
     __lowercase					=		None
     __lowercase					=		None
     self.run_pipeline_test(__snake_case					,	[]	)





   def 				snake_case__							(    self					,	lowerCAmelCase_					,	lowerCAmelCase_					,	lowerCAmelCase_	):
     if tokenizer is None or tokenizer.mask_token_id is None:
       self.skipTest("The provided tokenizer has no mask token, (probably reformer or wav2vec2)"	)

     __lowercase					=		FillMaskPipeline(model=__snake_case					,	tokenizer=__snake_case	)
     __lowercase					=		[
         f'''This is another {tokenizer.mask_token} test''',
     ]
     return fill_masker, examples





   def 				snake_case__							(    self					,	lowerCAmelCase_					,	lowerCAmelCase_	):
     __lowercase					=		fill_masker.tokenizer
     __lowercase					=		fill_masker.model

     __lowercase					=		fill_masker(
         f'''This is a {tokenizer.mask_token}'''					,	)
     self.assertEqual(
         __snake_case					,	[
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
         ]					,	)

     __lowercase					=		fill_masker([f'''This is a {tokenizer.mask_token}''']	)
     self.assertEqual(
         __snake_case					,	[
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
         ]					,	)

     __lowercase					=		fill_masker([f'''This is a {tokenizer.mask_token}''', f'''Another {tokenizer.mask_token} great test.''']	)
     self.assertEqual(
         __snake_case					,	[
             [
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             ],
             [
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             ],
         ]					,	)

     with self.assertRaises(__snake_case	):
       fill_masker([None]	)
     # No mask_token is not supported
     with self.assertRaises(__snake_case	):
       fill_masker("This is"	)

     self.run_test_top_k(__snake_case					,	__snake_case	)
     self.run_test_targets(__snake_case					,	__snake_case	)
     self.run_test_top_k_targets(__snake_case					,	__snake_case	)
     self.fill_mask_with_duplicate_targets_and_top_k(__snake_case					,	__snake_case	)
     self.fill_mask_with_multiple_masks(__snake_case					,	__snake_case	)





   def 				snake_case__							(    self					,	lowerCAmelCase_					,	lowerCAmelCase_	):
     __lowercase					=		tokenizer.get_vocab()
     __lowercase					=		sorted(vocab.keys()	)[:2]
     # Pipeline argument
     __lowercase					=		FillMaskPipeline(model=__snake_case					,	tokenizer=__snake_case					,	targets=__snake_case	)
     __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''	)
     self.assertEqual(
         __snake_case					,	[
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
         ]					,	)
     __lowercase					=		{vocab[el] for el in targets}
     self.assertEqual({el["token"] for el in outputs}					,	__snake_case	)
     __lowercase					=		[tokenizer.decode([x]	) for x in target_ids]
     self.assertEqual({el["token_str"] for el in outputs}					,	set(__snake_case	)	)

     # Call argument
     __lowercase					=		FillMaskPipeline(model=__snake_case					,	tokenizer=__snake_case	)
     __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''					,	targets=__snake_case	)
     self.assertEqual(
         __snake_case					,	[
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
         ]					,	)
     __lowercase					=		{vocab[el] for el in targets}
     self.assertEqual({el["token"] for el in outputs}					,	__snake_case	)
     __lowercase					=		[tokenizer.decode([x]	) for x in target_ids]
     self.assertEqual({el["token_str"] for el in outputs}					,	set(__snake_case	)	)

     # Score equivalence
     __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''					,	targets=__snake_case	)
     __lowercase					=		[top_mask["token_str"] for top_mask in outputs]
     __lowercase					=		[top_mask["score"] for top_mask in outputs]

     # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
     if set(__snake_case	) == set(__snake_case	):
       __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''					,	targets=__snake_case	)
       __lowercase					=		[top_mask["score"] for top_mask in unmasked_targets]
       self.assertEqual(nested_simplify(__snake_case	)					,	nested_simplify(__snake_case	)	)

     # Raises with invalid
     with self.assertRaises(__snake_case	):
       __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''					,	targets=[]	)
     # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
     if "" not in tokenizer.get_vocab():
       with self.assertRaises(__snake_case	):
         __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''					,	targets=[""]	)
       with self.assertRaises(__snake_case	):
         __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''					,	targets=""	)





   def 				snake_case__							(    self					,	lowerCAmelCase_					,	lowerCAmelCase_	):
     __lowercase					=		FillMaskPipeline(model=__snake_case					,	tokenizer=__snake_case					,	top_k=2	)
     __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''	)
     self.assertEqual(
         __snake_case					,	[
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
         ]					,	)

     __lowercase					=		FillMaskPipeline(model=__snake_case					,	tokenizer=__snake_case	)
     __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''					,	top_k=2	)
     self.assertEqual(
         __snake_case					,	[
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
         ]					,	)
     self.assertEqual(nested_simplify(__snake_case	)					,	nested_simplify(__snake_case	)	)





   def 				snake_case__							(    self					,	lowerCAmelCase_					,	lowerCAmelCase_	):
     __lowercase					=		tokenizer.get_vocab()
     __lowercase					=		FillMaskPipeline(model=__snake_case					,	tokenizer=__snake_case	)

     # top_k=2, ntargets=3
     __lowercase					=		sorted(vocab.keys()	)[:3]
     __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''					,	top_k=2					,	targets=__snake_case	)

     # If we use the most probably targets, and filter differently, we should still
     # have the same results
     __lowercase					=		[el["token_str"] for el in sorted(__snake_case					,	key=lambda lowerCAmelCase_	: x["score"]					,	reverse=__snake_case	)]
     # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
     if set(__snake_case	).issubset(__snake_case	):
       __lowercase					=		fill_masker(f'''This is a {tokenizer.mask_token}'''					,	top_k=3					,	targets=__snake_case	)
       # They should yield exactly the same result
       self.assertEqual(nested_simplify(__snake_case	)					,	nested_simplify(__snake_case	)	)





   def 				snake_case__							(    self					,	lowerCAmelCase_					,	lowerCAmelCase_	):
     __lowercase					=		FillMaskPipeline(model=__snake_case					,	tokenizer=__snake_case	)
     __lowercase					=		tokenizer.get_vocab()
     # String duplicates + id duplicates
     __lowercase					=		sorted(vocab.keys()	)[:3]
     __lowercase					=		[targets[0], targets[1], targets[0], targets[2], targets[1]]
     __lowercase					=		fill_masker(f'''My name is {tokenizer.mask_token}'''					,	targets=__snake_case					,	top_k=10	)

     # The target list contains duplicates, so we can't output more
     # than them
     self.assertEqual(len(__snake_case	)					,	3	)





   def 				snake_case__							(    self					,	lowerCAmelCase_					,	lowerCAmelCase_	):
     __lowercase					=		FillMaskPipeline(model=__snake_case					,	tokenizer=__snake_case	)

     __lowercase					=		fill_masker(
         f'''This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'''					,	top_k=2	)
     self.assertEqual(
         __snake_case					,	[
             [
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             ],
             [
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             ],
             [
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
                 {"sequence": ANY(__snake_case	), "score": ANY(__snake_case	), "token": ANY(__snake_case	), "token_str": ANY(__snake_case	)},
             ],
         ]					,	)








'''simple docstring'''




from . import (
    albert,
    align,
    altclip,
    audio_spectrogram_transformer,
    auto,
    autoformer,
    bark,
    bart,
    barthez,
    bartpho,
    beit,
    bert,
    bert_generation,
    bert_japanese,
    bertweet,
    big_bird,
    bigbird_pegasus,
    biogpt,
    bit,
    blenderbot,
    blenderbot_small,
    blip,
    blip_a,
    bloom,
    bridgetower,
    byta,
    camembert,
    canine,
    chinese_clip,
    clap,
    clip,
    clipseg,
    codegen,
    conditional_detr,
    convbert,
    convnext,
    convnextva,
    cpm,
    cpmant,
    ctrl,
    cvt,
    dataavec,
    deberta,
    deberta_va,
    decision_transformer,
    deformable_detr,
    deit,
    deprecated,
    deta,
    detr,
    dialogpt,
    dinat,
    distilbert,
    dit,
    donut,
    dpr,
    dpt,
    efficientformer,
    efficientnet,
    electra,
    encodec,
    encoder_decoder,
    ernie,
    ernie_m,
    esm,
    falcon,
    flaubert,
    flava,
    fnet,
    focalnet,
    fsmt,
    funnel,
    git,
    glpn,
    gpta,
    gpt_bigcode,
    gpt_neo,
    gpt_neox,
    gpt_neox_japanese,
    gpt_swa,
    gptj,
    gptsan_japanese,
    graphormer,
    groupvit,
    herbert,
    hubert,
    ibert,
    imagegpt,
    informer,
    instructblip,
    jukebox,
    layoutlm,
    layoutlmva,
    layoutlmva,
    layoutxlm,
    led,
    levit,
    lilt,
    llama,
    longformer,
    longta,
    luke,
    lxmert,
    mam_aaa,
    marian,
    markuplm,
    maskaformer,
    maskformer,
    mbart,
    mbartaa,
    mega,
    megatron_bert,
    megatron_gpta,
    mgp_str,
    mluke,
    mobilebert,
    mobilenet_va,
    mobilenet_va,
    mobilevit,
    mobilevitva,
    mpnet,
    mra,
    mta,
    musicgen,
    mvp,
    nat,
    nezha,
    nllb,
    nllb_moe,
    nystromformer,
    oneformer,
    open_llama,
    openai,
    opt,
    owlvit,
    pegasus,
    pegasus_x,
    perceiver,
    phobert,
    pixastruct,
    plbart,
    poolformer,
    prophetnet,
    qdqbert,
    rag,
    realm,
    reformer,
    regnet,
    rembert,
    resnet,
    roberta,
    roberta_prelayernorm,
    roc_bert,
    roformer,
    rwkv,
    sam,
    segformer,
    sew,
    sew_d,
    speech_encoder_decoder,
    speech_to_text,
    speech_to_text_a,
    speechta,
    splinter,
    squeezebert,
    swiftformer,
    swin,
    swinasr,
    swinva,
    switch_transformers,
    ta,
    table_transformer,
    tapas,
    time_series_transformer,
    timesformer,
    timm_backbone,
    transfo_xl,
    trocr,
    tvlt,
    umta,
    unispeech,
    unispeech_sat,
    upernet,
    videomae,
    vilt,
    vision_encoder_decoder,
    vision_text_dual_encoder,
    visual_bert,
    vit,
    vit_hybrid,
    vit_mae,
    vit_msn,
    vivit,
    wavaveca,
    wavaveca_conformer,
    wavaveca_phoneme,
    wavaveca_with_lm,
    wavlm,
    whisper,
    x_clip,
    xglm,
    xlm,
    xlm_prophetnet,
    xlm_roberta,
    xlm_roberta_xl,
    xlnet,
    xmod,
    yolos,
    yoso,
)

