


import os
import unittest

from transformers import MobileBertTokenizer, MobileBertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
@require_tokenizers
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_    ,					unittest.TestCase	):



     """simple docstring"""






     __magic_name__    			=    MobileBertTokenizer
     __magic_name__    			=    MobileBertTokenizerFast
     __magic_name__    			=    True
     __magic_name__    			=    True
     __magic_name__    			=    filter_non_english
     __magic_name__    			=    "google/mobilebert-uncased"







     def a	( self   ):

            '''simple docstring'''

            super().setUp()

            _lowerCAmelCase    :							Optional[int]   			=       [
                '[UNK]',
                '[CLS]',
                '[SEP]',
                '[PAD]',
                '[MASK]',
                'want',
                '##want',
                '##ed',
                'wa',
                'un',
                'runn',
                '##ing',
                ',',
                'low',
                'lowest',
            ]
            _lowerCAmelCase    :							Dict   			=       os.path.join(self.tmpdirname      ,	VOCAB_FILES_NAMES['vocab_file']   )
            with open(self.vocab_file      ,	'w'      ,	encoding='utf-8'   ) as vocab_writer:
                   vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]   )   )

            _lowerCAmelCase    :							Union[str, Any]   			=       [
                (tokenizer_def[0], self.pre_trained_model_path, tokenizer_def[2])  # else the 'google/' prefix is stripped
                for tokenizer_def in self.tokenizers_list
            ]







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       'UNwant\u00E9d,running'
            _lowerCAmelCase    :							List[Any]   			=       'unwanted, running'
            return input_text, output_text







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Dict   			=       self.tokenizer_class(self.vocab_file   )

            _lowerCAmelCase    :							int   			=       tokenizer.tokenize('UNwant\u00E9d,running'   )
            self.assertListEqual(snake_case__      ,	['un', '##want', '##ed', ',', 'runn', '##ing']   )
            self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case__   )      ,	[9, 6, 7, 12, 10, 11]   )







     def a	( self   ):

            '''simple docstring'''

            if not self.test_rust_tokenizer:
                   return

            _lowerCAmelCase    :							int   			=       self.get_tokenizer()
            _lowerCAmelCase    :							List[Any]   			=       self.get_rust_tokenizer()

            _lowerCAmelCase    :							Any   			=       'UNwant\u00E9d,running'

            _lowerCAmelCase    :							List[Any]   			=       tokenizer.tokenize(snake_case__   )
            _lowerCAmelCase    :							Tuple   			=       rust_tokenizer.tokenize(snake_case__   )
            self.assertListEqual(snake_case__      ,	snake_case__   )

            _lowerCAmelCase    :							Tuple   			=       tokenizer.encode(snake_case__      ,	add_special_tokens=snake_case__   )
            _lowerCAmelCase    :							List[str]   			=       rust_tokenizer.encode(snake_case__      ,	add_special_tokens=snake_case__   )
            self.assertListEqual(snake_case__      ,	snake_case__   )

            _lowerCAmelCase    :							int   			=       self.get_rust_tokenizer()
            _lowerCAmelCase    :							List[Any]   			=       tokenizer.encode(snake_case__   )
            _lowerCAmelCase    :							Optional[Any]   			=       rust_tokenizer.encode(snake_case__   )
            self.assertListEqual(snake_case__      ,	snake_case__   )

            # With lower casing
            _lowerCAmelCase    :							int   			=       self.get_tokenizer(do_lower_case=snake_case__   )
            _lowerCAmelCase    :							Tuple   			=       self.get_rust_tokenizer(do_lower_case=snake_case__   )

            _lowerCAmelCase    :							List[str]   			=       'UNwant\u00E9d,running'

            _lowerCAmelCase    :							Dict   			=       tokenizer.tokenize(snake_case__   )
            _lowerCAmelCase    :							int   			=       rust_tokenizer.tokenize(snake_case__   )
            self.assertListEqual(snake_case__      ,	snake_case__   )

            _lowerCAmelCase    :							Optional[int]   			=       tokenizer.encode(snake_case__      ,	add_special_tokens=snake_case__   )
            _lowerCAmelCase    :							Tuple   			=       rust_tokenizer.encode(snake_case__      ,	add_special_tokens=snake_case__   )
            self.assertListEqual(snake_case__      ,	snake_case__   )

            _lowerCAmelCase    :							Any   			=       self.get_rust_tokenizer()
            _lowerCAmelCase    :							Union[str, Any]   			=       tokenizer.encode(snake_case__   )
            _lowerCAmelCase    :							Any   			=       rust_tokenizer.encode(snake_case__   )
            self.assertListEqual(snake_case__      ,	snake_case__   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[Any]   			=       BasicTokenizer()

            self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'   )      ,	['ah', '\u535A', '\u63A8', 'zz']   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Tuple   			=       BasicTokenizer(do_lower_case=snake_case__   )

            self.assertListEqual(
                tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '   )      ,	['hello', '!', 'how', 'are', 'you', '?']   )
            self.assertListEqual(tokenizer.tokenize('H\u00E9llo'   )      ,	['hello']   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[Any]   			=       BasicTokenizer(do_lower_case=snake_case__      ,	strip_accents=snake_case__   )

            self.assertListEqual(
                tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '   )      ,	['hällo', '!', 'how', 'are', 'you', '?']   )
            self.assertListEqual(tokenizer.tokenize('H\u00E9llo'   )      ,	['h\u00E9llo']   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Any   			=       BasicTokenizer(do_lower_case=snake_case__      ,	strip_accents=snake_case__   )

            self.assertListEqual(
                tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '   )      ,	['hallo', '!', 'how', 'are', 'you', '?']   )
            self.assertListEqual(tokenizer.tokenize('H\u00E9llo'   )      ,	['hello']   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       BasicTokenizer(do_lower_case=snake_case__   )

            self.assertListEqual(
                tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '   )      ,	['hallo', '!', 'how', 'are', 'you', '?']   )
            self.assertListEqual(tokenizer.tokenize('H\u00E9llo'   )      ,	['hello']   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Union[str, Any]   			=       BasicTokenizer(do_lower_case=snake_case__   )

            self.assertListEqual(
                tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '   )      ,	['HeLLo', '!', 'how', 'Are', 'yoU', '?']   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       BasicTokenizer(do_lower_case=snake_case__      ,	strip_accents=snake_case__   )

            self.assertListEqual(
                tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '   )      ,	['HäLLo', '!', 'how', 'Are', 'yoU', '?']   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Tuple   			=       BasicTokenizer(do_lower_case=snake_case__      ,	strip_accents=snake_case__   )

            self.assertListEqual(
                tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '   )      ,	['HaLLo', '!', 'how', 'Are', 'yoU', '?']   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[Any]   			=       BasicTokenizer(do_lower_case=snake_case__      ,	never_split=['[UNK]']   )

            self.assertListEqual(
                tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'   )      ,	['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[Any]   			=       ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

            _lowerCAmelCase    :							List[str]   			=       {}
            for i, token in enumerate(snake_case__   ):
                   _lowerCAmelCase    :							List[Any]   			=       i
            _lowerCAmelCase    :							Tuple   			=       WordpieceTokenizer(vocab=snake_case__      ,	unk_token='[UNK]'   )

            self.assertListEqual(tokenizer.tokenize(''   )      ,	[]   )

            self.assertListEqual(tokenizer.tokenize('unwanted running'   )      ,	['un', '##want', '##ed', 'runn', '##ing']   )

            self.assertListEqual(tokenizer.tokenize('unwantedX running'   )      ,	['[UNK]', 'runn', '##ing']   )







     def a	( self   ):

            '''simple docstring'''

            self.assertTrue(_is_whitespace(' '   )   )
            self.assertTrue(_is_whitespace('\t'   )   )
            self.assertTrue(_is_whitespace('\r'   )   )
            self.assertTrue(_is_whitespace('\n'   )   )
            self.assertTrue(_is_whitespace('\u00A0'   )   )

            self.assertFalse(_is_whitespace('A'   )   )
            self.assertFalse(_is_whitespace('-'   )   )







     def a	( self   ):

            '''simple docstring'''

            self.assertTrue(_is_control('\u0005'   )   )

            self.assertFalse(_is_control('A'   )   )
            self.assertFalse(_is_control(' '   )   )
            self.assertFalse(_is_control('\t'   )   )
            self.assertFalse(_is_control('\r'   )   )







     def a	( self   ):

            '''simple docstring'''

            self.assertTrue(_is_punctuation('-'   )   )
            self.assertTrue(_is_punctuation('$'   )   )
            self.assertTrue(_is_punctuation('`'   )   )
            self.assertTrue(_is_punctuation('.'   )   )

            self.assertFalse(_is_punctuation('A'   )   )
            self.assertFalse(_is_punctuation(' '   )   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							str   			=       self.get_tokenizer()
            _lowerCAmelCase    :							Optional[Any]   			=       self.get_rust_tokenizer()

            # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
            self.assertListEqual([tokenizer.tokenize(snake_case__   ) for t in ['Test', '\xad', 'test']]      ,	[['[UNK]'], [], ['[UNK]']]   )

            self.assertListEqual(
                [rust_tokenizer.tokenize(snake_case__   ) for t in ['Test', '\xad', 'test']]      ,	[['[UNK]'], [], ['[UNK]']]   )







     @slow
     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       self.tokenizer_class.from_pretrained('google/mobilebert-uncased'   )

            _lowerCAmelCase    :							List[str]   			=       tokenizer.encode('sequence builders'      ,	add_special_tokens=snake_case__   )
            _lowerCAmelCase    :							List[str]   			=       tokenizer.encode('multi-sequence build'      ,	add_special_tokens=snake_case__   )

            _lowerCAmelCase    :							List[Any]   			=       tokenizer.build_inputs_with_special_tokens(snake_case__   )
            _lowerCAmelCase    :							int   			=       tokenizer.build_inputs_with_special_tokens(snake_case__      ,	snake_case__   )

            assert encoded_sentence == [101] + text + [102]
            assert encoded_pair == [101] + text + [102] + text_a + [102]







     def a	( self   ):

            '''simple docstring'''

            for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                   with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'   ):
                          _lowerCAmelCase    :							List[str]   			=       self.rust_tokenizer_class.from_pretrained(snake_case__      ,	**snake_case__   )

                          _lowerCAmelCase    :							Union[str, Any]   			=       F'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
                          _lowerCAmelCase    :							str   			=       tokenizer_r.encode_plus(
                              snake_case__      ,	return_attention_mask=snake_case__      ,	return_token_type_ids=snake_case__      ,	return_offsets_mapping=snake_case__      ,	add_special_tokens=snake_case__      ,	)

                          _lowerCAmelCase    :							Dict   			=       tokenizer_r.do_lower_case if hasattr(snake_case__      ,	'do_lower_case'   ) else False
                          _lowerCAmelCase    :							Union[str, Any]   			=       (
                              [
                                  ((0, 0), tokenizer_r.cls_token),
                                  ((0, 1), 'A'),
                                  ((1, 2), ','),
                                  ((3, 5), 'na'),
                                  ((5, 6), '##ï'),
                                  ((6, 8), '##ve'),
                                  ((9, 15), tokenizer_r.mask_token),
                                  ((16, 21), 'Allen'),
                                  ((21, 23), '##NL'),
                                  ((23, 24), '##P'),
                                  ((25, 33), 'sentence'),
                                  ((33, 34), '.'),
                                  ((0, 0), tokenizer_r.sep_token),
                              ]
                              if not do_lower_case
                              else [
                                  ((0, 0), tokenizer_r.cls_token),
                                  ((0, 1), 'a'),
                                  ((1, 2), ','),
                                  ((3, 8), 'naive'),
                                  ((9, 15), tokenizer_r.mask_token),
                                  ((16, 21), 'allen'),
                                  ((21, 23), '##nl'),
                                  ((23, 24), '##p'),
                                  ((25, 33), 'sentence'),
                                  ((33, 34), '.'),
                                  ((0, 0), tokenizer_r.sep_token),
                              ]
                          )

                          self.assertEqual(
                              [e[1] for e in expected_results]      ,	tokenizer_r.convert_ids_to_tokens(tokens['input_ids']   )   )
                          self.assertEqual([e[0] for e in expected_results]      ,	tokens['offset_mapping']   )







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Tuple   			=       ['的', '人', '有']
            _lowerCAmelCase    :							str   			=       ''.join(snake_case__   )
            for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                   with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'   ):
                          _lowerCAmelCase    :							Dict   			=       True
                          _lowerCAmelCase    :							Tuple   			=       self.tokenizer_class.from_pretrained(snake_case__      ,	**snake_case__   )
                          _lowerCAmelCase    :							Any   			=       self.rust_tokenizer_class.from_pretrained(snake_case__      ,	**snake_case__   )

                          _lowerCAmelCase    :							Union[str, Any]   			=       tokenizer_p.encode(snake_case__      ,	add_special_tokens=snake_case__   )
                          _lowerCAmelCase    :							Optional[int]   			=       tokenizer_r.encode(snake_case__      ,	add_special_tokens=snake_case__   )

                          _lowerCAmelCase    :							Optional[int]   			=       tokenizer_r.convert_ids_to_tokens(snake_case__   )
                          _lowerCAmelCase    :							str   			=       tokenizer_p.convert_ids_to_tokens(snake_case__   )

                          # it is expected that each Chinese character is not preceded by "##"
                          self.assertListEqual(snake_case__      ,	snake_case__   )
                          self.assertListEqual(snake_case__      ,	snake_case__   )

                          _lowerCAmelCase    :							Optional[int]   			=       False
                          _lowerCAmelCase    :							Optional[int]   			=       self.rust_tokenizer_class.from_pretrained(snake_case__      ,	**snake_case__   )
                          _lowerCAmelCase    :							List[str]   			=       self.tokenizer_class.from_pretrained(snake_case__      ,	**snake_case__   )

                          _lowerCAmelCase    :							List[Any]   			=       tokenizer_r.encode(snake_case__      ,	add_special_tokens=snake_case__   )
                          _lowerCAmelCase    :							Any   			=       tokenizer_p.encode(snake_case__      ,	add_special_tokens=snake_case__   )

                          _lowerCAmelCase    :							Tuple   			=       tokenizer_r.convert_ids_to_tokens(snake_case__   )
                          _lowerCAmelCase    :							Optional[int]   			=       tokenizer_p.convert_ids_to_tokens(snake_case__   )

                          # it is expected that only the first Chinese character is not preceded by "##".
                          _lowerCAmelCase    :							Any   			=       [
                              F'##{token}' if idx != 0 else token for idx, token in enumerate(snake_case__   )
                          ]
                          self.assertListEqual(snake_case__      ,	snake_case__   )
                          self.assertListEqual(snake_case__      ,	snake_case__   )





'''simple docstring'''







from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


lowerCAmelCase    :     str					=						logging.get_logger(__name__)

# General docstring
lowerCAmelCase    :     Optional[Any]					=						"""RegNetConfig"""

# Base docstring
lowerCAmelCase    :     int					=						"""facebook/regnet-y-040"""
lowerCAmelCase    :     Optional[Any]					=						[1, 10_88, 7, 7]

# Image classification docstring
lowerCAmelCase    :     Any					=						"""facebook/regnet-y-040"""
lowerCAmelCase    :     Optional[Any]					=						"""tabby, tabby cat"""

lowerCAmelCase    :     Tuple					=						[
    """facebook/regnet-y-040""",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__ = 3      ,	snake_case__ = 1      ,	snake_case__ = 1      ,	snake_case__ = "relu"      ,	**snake_case__      ,	):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            # The padding and conv has been verified in
            # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
            _lowerCAmelCase    :							Optional[Any]   			=       tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2   )
            _lowerCAmelCase    :							List[Any]   			=       tf.keras.layers.ConvaD(
                filters=snake_case__      ,	kernel_size=snake_case__      ,	strides=snake_case__      ,	padding='VALID'      ,	groups=snake_case__      ,	use_bias=snake_case__      ,	name='convolution'      ,	)
            _lowerCAmelCase    :							List[Any]   			=       tf.keras.layers.BatchNormalization(epsilon=1E-5      ,	momentum=0.9      ,	name='normalization'   )
            _lowerCAmelCase    :							int   			=       ACTaFN[activation] if activation is not None else tf.identity







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Any   			=       self.convolution(self.padding(snake_case__   )   )
            _lowerCAmelCase    :							Union[str, Any]   			=       self.normalization(snake_case__   )
            _lowerCAmelCase    :							int   			=       self.activation(snake_case__   )
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							str   			=       config.num_channels
            _lowerCAmelCase    :							List[Any]   			=       TFRegNetConvLayer(
                out_channels=config.embedding_size      ,	kernel_size=3      ,	stride=2      ,	activation=config.hidden_act      ,	name='embedder'      ,	)







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[Any]   			=       shape_list(snake_case__   )[1]
            if tf.executing_eagerly() and num_channels != self.num_channels:
                   raise ValueError(
                       'Make sure that the channel dimension of the pixel values match with the one set in the configuration.'   )

            # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
            # So change the input format from `NCHW` to `NHWC`.
            # shape = (batch_size, in_height, in_width, in_channels=num_channels)
            _lowerCAmelCase    :							List[Any]   			=       tf.transpose(snake_case__      ,	perm=(0, 2, 3, 1)   )
            _lowerCAmelCase    :							Tuple   			=       self.embedder(snake_case__   )
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__ = 2      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							Union[str, Any]   			=       tf.keras.layers.ConvaD(
                filters=snake_case__      ,	kernel_size=1      ,	strides=snake_case__      ,	use_bias=snake_case__      ,	name='convolution'   )
            _lowerCAmelCase    :							Tuple   			=       tf.keras.layers.BatchNormalization(epsilon=1E-5      ,	momentum=0.9      ,	name='normalization'   )







     def a	( self      ,	snake_case__      ,	snake_case__ = False   ):

            '''simple docstring'''

            return self.normalization(self.convolution(snake_case__   )      ,	training=snake_case__   )
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							Any   			=       tf.keras.layers.GlobalAveragePoolingaD(keepdims=snake_case__      ,	name='pooler'   )
            _lowerCAmelCase    :							str   			=       [
                tf.keras.layers.ConvaD(filters=snake_case__      ,	kernel_size=1      ,	activation='relu'      ,	name='attention.0'   ),
                tf.keras.layers.ConvaD(filters=snake_case__      ,	kernel_size=1      ,	activation='sigmoid'      ,	name='attention.2'   ),
            ]







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Any   			=       self.pooler(snake_case__   )
            for layer_module in self.attention:
                   _lowerCAmelCase    :							Tuple   			=       layer_module(snake_case__   )
            _lowerCAmelCase    :							Optional[Any]   			=       hidden_state * pooled
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__      ,	snake_case__      ,	snake_case__ = 1      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							Optional[int]   			=       in_channels != out_channels or stride != 1
            _lowerCAmelCase    :							Union[str, Any]   			=       max(1      ,	out_channels // config.groups_width   )
            _lowerCAmelCase    :							Optional[Any]   			=       (
                TFRegNetShortCut(snake_case__      ,	stride=snake_case__      ,	name='shortcut'   )
                if should_apply_shortcut
                else tf.keras.layers.Activation('linear'      ,	name='shortcut'   )
            )
            # `self.layers` instead of `self.layer` because that is a reserved argument.
            _lowerCAmelCase    :							Any   			=       [
                TFRegNetConvLayer(snake_case__      ,	kernel_size=1      ,	activation=config.hidden_act      ,	name='layer.0'   ),
                TFRegNetConvLayer(
                    snake_case__      ,	stride=snake_case__      ,	groups=snake_case__      ,	activation=config.hidden_act      ,	name='layer.1'   ),
                TFRegNetConvLayer(snake_case__      ,	kernel_size=1      ,	activation=snake_case__      ,	name='layer.2'   ),
            ]
            _lowerCAmelCase    :							List[str]   			=       ACTaFN[config.hidden_act]







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[Any]   			=       hidden_state
            for layer_module in self.layers:
                   _lowerCAmelCase    :							int   			=       layer_module(snake_case__   )
            _lowerCAmelCase    :							int   			=       self.shortcut(snake_case__   )
            hidden_state += residual
            _lowerCAmelCase    :							Tuple   			=       self.activation(snake_case__   )
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__      ,	snake_case__      ,	snake_case__ = 1      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							List[str]   			=       in_channels != out_channels or stride != 1
            _lowerCAmelCase    :							Union[str, Any]   			=       max(1      ,	out_channels // config.groups_width   )
            _lowerCAmelCase    :							Optional[Any]   			=       (
                TFRegNetShortCut(snake_case__      ,	stride=snake_case__      ,	name='shortcut'   )
                if should_apply_shortcut
                else tf.keras.layers.Activation('linear'      ,	name='shortcut'   )
            )
            _lowerCAmelCase    :							Tuple   			=       [
                TFRegNetConvLayer(snake_case__      ,	kernel_size=1      ,	activation=config.hidden_act      ,	name='layer.0'   ),
                TFRegNetConvLayer(
                    snake_case__      ,	stride=snake_case__      ,	groups=snake_case__      ,	activation=config.hidden_act      ,	name='layer.1'   ),
                TFRegNetSELayer(snake_case__      ,	reduced_channels=int(round(in_channels / 4   )   )      ,	name='layer.2'   ),
                TFRegNetConvLayer(snake_case__      ,	kernel_size=1      ,	activation=snake_case__      ,	name='layer.3'   ),
            ]
            _lowerCAmelCase    :							Tuple   			=       ACTaFN[config.hidden_act]







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Dict   			=       hidden_state
            for layer_module in self.layers:
                   _lowerCAmelCase    :							List[Any]   			=       layer_module(snake_case__   )
            _lowerCAmelCase    :							Tuple   			=       self.shortcut(snake_case__   )
            hidden_state += residual
            _lowerCAmelCase    :							str   			=       self.activation(snake_case__   )
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	snake_case__      ,	snake_case__      ,	snake_case__ = 2      ,	snake_case__ = 2      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )

            _lowerCAmelCase    :							Dict   			=       TFRegNetXLayer if config.layer_type == 'x' else TFRegNetYLayer
            _lowerCAmelCase    :							Optional[int]   			=       [
                # downsampling is done in the first layer with stride of 2
                layer(snake_case__      ,	snake_case__      ,	snake_case__      ,	stride=snake_case__      ,	name='layers.0'   ),
                *[layer(snake_case__      ,	snake_case__      ,	snake_case__      ,	name=F'layers.{i+1}'   ) for i in range(depth - 1   )],
            ]







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            for layer_module in self.layers:
                   _lowerCAmelCase    :							int   			=       layer_module(snake_case__   )
            return hidden_state
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							str   			=       []
            # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
            self.stages.append(
                TFRegNetStage(
                    snake_case__      ,	config.embedding_size      ,	config.hidden_sizes[0]      ,	stride=2 if config.downsample_in_first_stage else 1      ,	depth=config.depths[0]      ,	name='stages.0'      ,	)   )
            _lowerCAmelCase    :							Union[str, Any]   			=       zip(config.hidden_sizes      ,	config.hidden_sizes[1:]   )
            for i, ((in_channels, out_channels), depth) in enumerate(zip(snake_case__      ,	config.depths[1:]   )   ):
                   self.stages.append(TFRegNetStage(snake_case__      ,	snake_case__      ,	snake_case__      ,	depth=snake_case__      ,	name=F'stages.{i+1}'   )   )







     def a	( self      ,	snake_case__      ,	snake_case__ = False      ,	snake_case__ = True   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[Any]   			=       () if output_hidden_states else None

            for stage_module in self.stages:
                   if output_hidden_states:
                          _lowerCAmelCase    :							str   			=       hidden_states + (hidden_state,)

                   _lowerCAmelCase    :							List[str]   			=       stage_module(snake_case__   )

            if output_hidden_states:
                   _lowerCAmelCase    :							Dict   			=       hidden_states + (hidden_state,)

            if not return_dict:
                   return tuple(v for v in [hidden_state, hidden_states] if v is not None   )

            return TFBaseModelOutputWithNoAttention(last_hidden_state=snake_case__      ,	hidden_states=snake_case__   )
@keras_serializable
class 	UpperCamelCase__					( tf.keras.layers.Layer	):



     """simple docstring"""






     __magic_name__    			=    RegNetConfig







     def __init__( self      ,	snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(**snake_case__   )
            _lowerCAmelCase    :							Union[str, Any]   			=       config
            _lowerCAmelCase    :							Union[str, Any]   			=       TFRegNetEmbeddings(snake_case__      ,	name='embedder'   )
            _lowerCAmelCase    :							Optional[int]   			=       TFRegNetEncoder(snake_case__      ,	name='encoder'   )
            _lowerCAmelCase    :							Dict   			=       tf.keras.layers.GlobalAveragePoolingaD(keepdims=snake_case__      ,	name='pooler'   )







     @unpack_inputs
     def a	( self      ,	snake_case__      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__ = False      ,	):

            '''simple docstring'''

            _lowerCAmelCase    :							Tuple   			=       (
                output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
            )
            _lowerCAmelCase    :							Optional[Any]   			=       return_dict if return_dict is not None else self.config.use_return_dict

            _lowerCAmelCase    :							int   			=       self.embedder(snake_case__      ,	training=snake_case__   )

            _lowerCAmelCase    :							List[str]   			=       self.encoder(
                snake_case__      ,	output_hidden_states=snake_case__      ,	return_dict=snake_case__      ,	training=snake_case__   )

            _lowerCAmelCase    :							List[Any]   			=       encoder_outputs[0]
            _lowerCAmelCase    :							Tuple   			=       self.pooler(snake_case__   )

            # Change to NCHW output format have uniformity in the modules
            _lowerCAmelCase    :							Optional[int]   			=       tf.transpose(snake_case__      ,	perm=(0, 3, 1, 2)   )
            _lowerCAmelCase    :							Optional[Any]   			=       tf.transpose(snake_case__      ,	perm=(0, 3, 1, 2)   )

            # Change the other hidden state outputs to NCHW as well
            if output_hidden_states:
                   _lowerCAmelCase    :							Union[str, Any]   			=       tuple([tf.transpose(snake_case__      ,	perm=(0, 3, 1, 2)   ) for h in encoder_outputs[1]]   )

            if not return_dict:
                   return (last_hidden_state, pooled_output) + encoder_outputs[1:]

            return TFBaseModelOutputWithPoolingAndNoAttention(
                last_hidden_state=snake_case__      ,	pooler_output=snake_case__      ,	hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states      ,	)
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_	):



     """simple docstring"""






     __magic_name__    			=    RegNetConfig
     __magic_name__    			=    "regnet"
     __magic_name__    			=    "pixel_values"







     @property
     def a	( self   ):

            '''simple docstring'''

            return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)      ,	dtype=tf.floataa   )}
lowerCAmelCase    :     List[Any]					=						r"""
    Parameters:
    This model is a Tensorflow
    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a
    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and
    behavior.
        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.
"""

lowerCAmelCase    :     Dict					=						r"""
    Args:
        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConveNextImageProcessor.__call__`] for details.
        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""
@add_start_docstrings(
    "The bare RegNet model outputting raw features without any specific head on top."    ,					SCREAMING_SNAKE_CASE_    ,					)
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	*snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(snake_case__      ,	*snake_case__      ,	**snake_case__   )
            _lowerCAmelCase    :							List[str]   			=       TFRegNetMainLayer(snake_case__      ,	name='regnet'   )







     @unpack_inputs
     @add_start_docstrings_to_model_forward(snake_case__   )
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC      ,	output_type=snake_case__      ,	config_class=_CONFIG_FOR_DOC      ,	modality='vision'      ,	expected_output=_EXPECTED_OUTPUT_SHAPE      ,	)
     def a	( self      ,	snake_case__      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__=False      ,	):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[Any]   			=       (
                output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
            )
            _lowerCAmelCase    :							Any   			=       return_dict if return_dict is not None else self.config.use_return_dict

            _lowerCAmelCase    :							str   			=       self.regnet(
                pixel_values=snake_case__      ,	output_hidden_states=snake_case__      ,	return_dict=snake_case__      ,	training=snake_case__      ,	)
            if not return_dict:
                   return (outputs[0],) + outputs[1:]

            return TFBaseModelOutputWithPoolingAndNoAttention(
                last_hidden_state=outputs.last_hidden_state      ,	pooler_output=outputs.pooler_output      ,	hidden_states=outputs.hidden_states      ,	)
@add_start_docstrings(
    "\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "    ,					SCREAMING_SNAKE_CASE_    ,					)
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_    ,					SCREAMING_SNAKE_CASE_	):



     """simple docstring"""






     def __init__( self      ,	snake_case__      ,	*snake_case__      ,	**snake_case__   ):

            '''simple docstring'''

            super().__init__(snake_case__      ,	*snake_case__      ,	**snake_case__   )
            _lowerCAmelCase    :							Optional[Any]   			=       config.num_labels
            _lowerCAmelCase    :							Optional[Any]   			=       TFRegNetMainLayer(snake_case__      ,	name='regnet'   )
            # classification head
            _lowerCAmelCase    :							Optional[int]   			=       [
                tf.keras.layers.Flatten(),
                tf.keras.layers.Dense(config.num_labels      ,	name='classifier.1'   ) if config.num_labels > 0 else tf.identity,
            ]







     @unpack_inputs
     @add_start_docstrings_to_model_forward(snake_case__   )
     @add_code_sample_docstrings(
         checkpoint=_IMAGE_CLASS_CHECKPOINT      ,	output_type=snake_case__      ,	config_class=_CONFIG_FOR_DOC      ,	expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT      ,	)
     def a	( self      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__=False      ,	):

            '''simple docstring'''

            _lowerCAmelCase    :							int   			=       (
                output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
            )
            _lowerCAmelCase    :							List[str]   			=       return_dict if return_dict is not None else self.config.use_return_dict

            _lowerCAmelCase    :							Dict   			=       self.regnet(
                snake_case__      ,	output_hidden_states=snake_case__      ,	return_dict=snake_case__      ,	training=snake_case__   )

            _lowerCAmelCase    :							Optional[Any]   			=       outputs.pooler_output if return_dict else outputs[1]

            _lowerCAmelCase    :							List[Any]   			=       self.classifier[0](snake_case__   )
            _lowerCAmelCase    :							Tuple   			=       self.classifier[1](snake_case__   )

            _lowerCAmelCase    :							int   			=       None if labels is None else self.hf_compute_loss(labels=snake_case__      ,	logits=snake_case__   )

            if not return_dict:
                   _lowerCAmelCase    :							str   			=       (logits,) + outputs[2:]
                   return ((loss,) + output) if loss is not None else output

            return TFSequenceClassifierOutput(loss=snake_case__      ,	logits=snake_case__      ,	hidden_states=outputs.hidden_states   )

