

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        _A						(     unittest.TestCase):
  SCREAMING_SNAKE_CASE			:					str				=     MODEL_FOR_MASKED_LM_MAPPING
  SCREAMING_SNAKE_CASE			:					List[Any]				=     TF_MODEL_FOR_MASKED_LM_MAPPING

  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        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        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Dict							=   pipeline(task='fill-mask'       ,    model='sshleifer/tiny-distilroberta-base'       ,    top_k=2       ,    framework='tf'    )
        SCREAMING_SNAKE_CASE_ :     Any							=   unmasker('My name is <mask>'    )
        self.assertEqual(
            nested_simplify(_a       ,    decimals=6    )       ,    [
                {'sequence': 'My name is grouped', 'score': 2.1e-05, 'token': 3_8015, 'token_str': ' grouped'},
                {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 2_5506, 'token_str': ' accuser'},
            ]       ,    )

        SCREAMING_SNAKE_CASE_ :     Dict							=   unmasker('The largest city in France is <mask>'    )
        self.assertEqual(
            nested_simplify(_a       ,    decimals=6    )       ,    [
                {
                    'sequence': 'The largest city in France is grouped',
                    'score': 2.1e-05,
                    'token': 3_8015,
                    'token_str': ' grouped',
                },
                {
                    'sequence': 'The largest city in France is accuser',
                    'score': 2.1e-05,
                    'token': 2_5506,
                    'token_str': ' accuser',
                },
            ]       ,    )

        SCREAMING_SNAKE_CASE_ :     str							=   unmasker('My name is <mask>'       ,    targets=[' Patrick', ' Clara', ' Teven']       ,    top_k=3    )
        self.assertEqual(
            nested_simplify(_a       ,    decimals=6    )       ,    [
                {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 1_3606, 'token_str': ' Clara'},
                {'sequence': 'My name is Patrick', 'score': 2e-05, 'token': 3499, 'token_str': ' Patrick'},
                {'sequence': 'My name is Te', 'score': 1.9e-05, 'token': 2941, 'token_str': ' Te'},
            ]       ,    )

  @require_torch
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   pipeline(task='fill-mask'       ,    model='sshleifer/tiny-distilroberta-base'       ,    top_k=2       ,    framework='pt'    )

        SCREAMING_SNAKE_CASE_ :     int							=   unmasker('My name is <mask>'    )
        self.assertEqual(
            nested_simplify(_a       ,    decimals=6    )       ,    [
                {'sequence': 'My name is Maul', 'score': 2.2e-05, 'token': 3_5676, 'token_str': ' Maul'},
                {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 1_6416, 'token_str': 'ELS'},
            ]       ,    )

        SCREAMING_SNAKE_CASE_ :     int							=   unmasker('The largest city in France is <mask>'    )
        self.assertEqual(
            nested_simplify(_a       ,    decimals=6    )       ,    [
                {
                    'sequence': 'The largest city in France is Maul',
                    'score': 2.2e-05,
                    'token': 3_5676,
                    'token_str': ' Maul',
                },
                {'sequence': 'The largest city in France isELS', 'score': 2.2e-05, 'token': 1_6416, 'token_str': 'ELS'},
            ]       ,    )

        SCREAMING_SNAKE_CASE_ :     Any							=   unmasker('My name is <mask>'       ,    targets=[' Patrick', ' Clara', ' Teven']       ,    top_k=3    )
        self.assertEqual(
            nested_simplify(_a       ,    decimals=6    )       ,    [
                {'sequence': 'My name is Patrick', 'score': 2.1e-05, 'token': 3499, 'token_str': ' Patrick'},
                {'sequence': 'My name is Te', 'score': 2e-05, 'token': 2941, 'token_str': ' Te'},
                {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 1_3606, 'token_str': ' Clara'},
            ]       ,    )

        SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   unmasker('My name is <mask> <mask>'       ,    top_k=2    )

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

  @require_torch_gpu
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     List[str]							=   pipeline('fill-mask'       ,    model='hf-internal-testing/tiny-random-distilbert'       ,    device=0       ,    framework='pt'    )

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

        SCREAMING_SNAKE_CASE_ :     int							=   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(_a       ,    _a    )

  @slow
  @require_torch
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   pipeline(task='fill-mask'       ,    model='distilroberta-base'       ,    top_k=2       ,    framework='pt'    )
        self.run_large_test(_a    )

  @slow
  @require_tf
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     str							=   pipeline(task='fill-mask'       ,    model='distilroberta-base'       ,    top_k=2       ,    framework='tf'    )
        self.run_large_test(_a    )

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   unmasker('My name is <mask>'    )
        self.assertEqual(
            nested_simplify(_a    )       ,    [
                {'sequence': 'My name is John', 'score': 0.008, 'token': 610, 'token_str': ' John'},
                {'sequence': 'My name is Chris', 'score': 0.007, 'token': 1573, 'token_str': ' Chris'},
            ]       ,    )
        SCREAMING_SNAKE_CASE_ :     Any							=   unmasker('The largest city in France is <mask>'    )
        self.assertEqual(
            nested_simplify(_a    )       ,    [
                {
                    'sequence': 'The largest city in France is Paris',
                    'score': 0.251,
                    'token': 2201,
                    'token_str': ' Paris',
                },
                {
                    'sequence': 'The largest city in France is Lyon',
                    'score': 0.214,
                    'token': 1_2790,
                    'token_str': ' Lyon',
                },
            ]       ,    )

        SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   unmasker('My name is <mask>'       ,    targets=[' Patrick', ' Clara', ' Teven']       ,    top_k=3    )
        self.assertEqual(
            nested_simplify(_a    )       ,    [
                {'sequence': 'My name is Patrick', 'score': 0.005, 'token': 3499, 'token_str': ' Patrick'},
                {'sequence': 'My name is Clara', 'score': 0.000, 'token': 1_3606, 'token_str': ' Clara'},
                {'sequence': 'My name is Te', 'score': 0.000, 'token': 2941, 'token_str': ' Te'},
            ]       ,    )

  @require_torch
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     str							=   pipeline(task='fill-mask'       ,    model='sshleifer/tiny-distilroberta-base'       ,    framework='pt'    )
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   None
        SCREAMING_SNAKE_CASE_ :     Dict							=   None
        self.run_pipeline_test(_a       ,    []    )

  @require_tf
  def        UpperCAmelCase			( self    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   pipeline(task='fill-mask'       ,    model='sshleifer/tiny-distilroberta-base'       ,    framework='tf'    )
        SCREAMING_SNAKE_CASE_ :     int							=   None
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   None
        self.run_pipeline_test(_a       ,    []    )

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







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

        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   FillMaskPipeline(model=_a       ,    tokenizer=_a    )
        SCREAMING_SNAKE_CASE_ :     Tuple							=   [
            f"This is another {tokenizer.mask_token} test",
        ]
        return fill_masker, examples

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   fill_masker.tokenizer
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   fill_masker.model

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

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

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

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

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

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     str							=   tokenizer.get_vocab()
        SCREAMING_SNAKE_CASE_ :     str							=   sorted(vocab.keys()    )[:2]
        # Pipeline argument
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   FillMaskPipeline(model=_a       ,    tokenizer=_a       ,    targets=_a    )
        SCREAMING_SNAKE_CASE_ :     Any							=   fill_masker(f"This is a {tokenizer.mask_token}"    )
        self.assertEqual(
            _a       ,    [
                {'sequence': ANY(_a    ), 'score': ANY(_a    ), 'token': ANY(_a    ), 'token_str': ANY(_a    )},
                {'sequence': ANY(_a    ), 'score': ANY(_a    ), 'token': ANY(_a    ), 'token_str': ANY(_a    )},
            ]       ,    )
        SCREAMING_SNAKE_CASE_ :     List[str]							=   {vocab[el] for el in targets}
        self.assertEqual({el['token'] for el in outputs}       ,    _a    )
        SCREAMING_SNAKE_CASE_ :     Tuple							=   [tokenizer.decode([x]    ) for x in target_ids]
        self.assertEqual({el['token_str'] for el in outputs}       ,    set(_a    )    )

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

        # Score equivalence
        SCREAMING_SNAKE_CASE_ :     Optional[Any]							=   fill_masker(f"This is a {tokenizer.mask_token}"       ,    targets=_a    )
        SCREAMING_SNAKE_CASE_ :     List[str]							=   [top_mask['token_str'] for top_mask in outputs]
        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   [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(_a    ) == set(_a    ):
              SCREAMING_SNAKE_CASE_ :     Dict							=   fill_masker(f"This is a {tokenizer.mask_token}"       ,    targets=_a    )
              SCREAMING_SNAKE_CASE_ :     int							=   [top_mask['score'] for top_mask in unmasked_targets]
              self.assertEqual(nested_simplify(_a    )       ,    nested_simplify(_a    )    )

        # Raises with invalid
        with self.assertRaises(_a    ):
              SCREAMING_SNAKE_CASE_ :     List[str]							=   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(_a    ):
                    SCREAMING_SNAKE_CASE_ :     Any							=   fill_masker(f"This is a {tokenizer.mask_token}"       ,    targets=['']    )
              with self.assertRaises(_a    ):
                    SCREAMING_SNAKE_CASE_ :     List[Any]							=   fill_masker(f"This is a {tokenizer.mask_token}"       ,    targets=''    )

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     List[str]							=   FillMaskPipeline(model=_a       ,    tokenizer=_a       ,    top_k=2    )
        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   fill_masker(f"This is a {tokenizer.mask_token}"    )
        self.assertEqual(
            _a       ,    [
                {'sequence': ANY(_a    ), 'score': ANY(_a    ), 'token': ANY(_a    ), 'token_str': ANY(_a    )},
                {'sequence': ANY(_a    ), 'score': ANY(_a    ), 'token': ANY(_a    ), 'token_str': ANY(_a    )},
            ]       ,    )

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

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     int							=   tokenizer.get_vocab()
        SCREAMING_SNAKE_CASE_ :     Dict							=   FillMaskPipeline(model=_a       ,    tokenizer=_a    )

        # top_k=2, ntargets=3
        SCREAMING_SNAKE_CASE_ :     str							=   sorted(vocab.keys()    )[:3]
        SCREAMING_SNAKE_CASE_ :     str							=   fill_masker(f"This is a {tokenizer.mask_token}"       ,    top_k=2       ,    targets=_a    )

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

  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Dict							=   FillMaskPipeline(model=_a       ,    tokenizer=_a    )
        SCREAMING_SNAKE_CASE_ :     int							=   tokenizer.get_vocab()
        # String duplicates + id duplicates
        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   sorted(vocab.keys()    )[:3]
        SCREAMING_SNAKE_CASE_ :     List[Any]							=   [targets[0], targets[1], targets[0], targets[2], targets[1]]
        SCREAMING_SNAKE_CASE_ :     Optional[int]							=   fill_masker(f"My name is {tokenizer.mask_token}"       ,    targets=_a       ,    top_k=10    )

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



  def        UpperCAmelCase			( self       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE    ):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_ :     Union[str, Any]							=   FillMaskPipeline(model=_a       ,    tokenizer=_a    )

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









'''simple docstring'''
from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


lowerCamelCase :      List[str]					 =     logging.get_logger(__name__)

lowerCamelCase :      List[Any]					 =     {
    "facebook/convnextv2-tiny-1k-224": "https://huggingface.co/facebook/convnextv2-tiny-1k-224/resolve/main/config.json",
}







class 							A__    (       A__     ,   A__  ):
  A__		 =				'convnextv2'





  def __init__(		self      :	Tuple							,					_a      :	Optional[int]=3							,					_a      :	Any=4							,					_a      :	int=4							,					_a      :	Union[str, Any]=None							,					_a      :	List[str]=None							,					_a      :	Optional[Any]="gelu"							,					_a      :	Any=0.02							,					_a      :	Any=1e-12							,					_a      :	Tuple=0.0							,					_a      :	int=224							,					_a      :	Any=None							,					_a      :	Optional[int]=None							,					**_a      :	List[str]							,					)	->    Optional[Any]:





       '''simple docstring'''






       super().__init__(**_a )

       _SCREAMING_SNAKE_CASE							    =num_channels
       _SCREAMING_SNAKE_CASE							    =patch_size
       _SCREAMING_SNAKE_CASE							    =num_stages
       _SCREAMING_SNAKE_CASE							    =[96, 192, 384, 768] if hidden_sizes is None else hidden_sizes
       _SCREAMING_SNAKE_CASE							    =[3, 3, 9, 3] if depths is None else depths
       _SCREAMING_SNAKE_CASE							    =hidden_act
       _SCREAMING_SNAKE_CASE							    =initializer_range
       _SCREAMING_SNAKE_CASE							    =layer_norm_eps
       _SCREAMING_SNAKE_CASE							    =drop_path_rate
       _SCREAMING_SNAKE_CASE							    =image_size
       _SCREAMING_SNAKE_CASE							    =['stem'] + [f"stage{idx}" for idx in range(1							,					len(self.depths ) + 1 )]
       _SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE							    =get_aligned_output_features_output_indices(
           out_features=_a							,					out_indices=_a							,					stage_names=self.stage_names )
