



'''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


SCREAMING_SNAKE_CASE__          =  logging.get_logger(__name__)

# General docstring
SCREAMING_SNAKE_CASE__          =  "RegNetConfig"

# Base docstring
SCREAMING_SNAKE_CASE__          =  "facebook/regnet-y-040"
SCREAMING_SNAKE_CASE__          =  [1, 1088, 7, 7]

# Image classification docstring
SCREAMING_SNAKE_CASE__          =  "facebook/regnet-y-040"
SCREAMING_SNAKE_CASE__          =  "tabby, tabby cat"

SCREAMING_SNAKE_CASE__          =  [
    "facebook/regnet-y-040",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]


class 					snake_case			(tf.keras.layers.Layer ):



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







       def 				_a   (					self  ,UpperCAmelCase_   )	->				Any:
           lowercase__									=    self.convolution(self.padding(UpperCAmelCase_   )   )
           lowercase__									=    self.normalization(UpperCAmelCase_   )
           lowercase__									=    self.activation(UpperCAmelCase_   )
           return hidden_state





class 					snake_case			(tf.keras.layers.Layer ):



       def __init__(					self  ,UpperCAmelCase_  ,**UpperCAmelCase_   )	->				Optional[Any]:
           super().__init__(**UpperCAmelCase_   )
           lowercase__									=    config.num_channels
           lowercase__									=    TFRegNetConvLayer(
               out_channels=config.embedding_size  ,kernel_size=3  ,stride=2  ,activation=config.hidden_act  ,name="embedder"  ,)







       def 				_a   (					self  ,UpperCAmelCase_   )	->				List[str]:
           lowercase__									=    shape_list(UpperCAmelCase_   )[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)
           lowercase__									=    tf.transpose(UpperCAmelCase_  ,perm=(0, 2, 3, 1)   )
           lowercase__									=    self.embedder(UpperCAmelCase_   )
           return hidden_state





class 					snake_case			(tf.keras.layers.Layer ):



       def __init__(					self  ,UpperCAmelCase_  ,UpperCAmelCase_ = 2  ,**UpperCAmelCase_   )	->				Optional[int]:
           super().__init__(**UpperCAmelCase_   )
           lowercase__									=    tf.keras.layers.ConvaD(
               filters=UpperCAmelCase_  ,kernel_size=1  ,strides=UpperCAmelCase_  ,use_bias=UpperCAmelCase_  ,name="convolution"   )
           lowercase__									=    tf.keras.layers.BatchNormalization(epsilon=1E-5  ,momentum=0.9  ,name="normalization"   )







       def 				_a   (					self  ,UpperCAmelCase_  ,UpperCAmelCase_ = False   )	->				tf.Tensor:
           return self.normalization(self.convolution(UpperCAmelCase_   )  ,training=UpperCAmelCase_   )





class 					snake_case			(tf.keras.layers.Layer ):



       def __init__(					self  ,UpperCAmelCase_  ,UpperCAmelCase_  ,**UpperCAmelCase_   )	->				Tuple:
           super().__init__(**UpperCAmelCase_   )
           lowercase__									=    tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCAmelCase_  ,name="pooler"   )
           lowercase__									=    [
               tf.keras.layers.ConvaD(filters=UpperCAmelCase_  ,kernel_size=1  ,activation="relu"  ,name="attention.0"   ),
               tf.keras.layers.ConvaD(filters=UpperCAmelCase_  ,kernel_size=1  ,activation="sigmoid"  ,name="attention.2"   ),
           ]







       def 				_a   (					self  ,UpperCAmelCase_   )	->				Optional[int]:
           # [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
           lowercase__									=    self.pooler(UpperCAmelCase_   )
           for layer_module in self.attention:
               lowercase__									=    layer_module(UpperCAmelCase_   )
           lowercase__									=    hidden_state * pooled
           return hidden_state





class 					snake_case			(tf.keras.layers.Layer ):



       def __init__(					self  ,UpperCAmelCase_  ,UpperCAmelCase_  ,UpperCAmelCase_  ,UpperCAmelCase_ = 1  ,**UpperCAmelCase_   )	->				str:
           super().__init__(**UpperCAmelCase_   )
           lowercase__									=    in_channels != out_channels or stride != 1
           lowercase__									=    max(1  ,out_channels // config.groups_width   )
           lowercase__									=    (
               TFRegNetShortCut(UpperCAmelCase_  ,stride=UpperCAmelCase_  ,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.
           lowercase__									=    [
               TFRegNetConvLayer(UpperCAmelCase_  ,kernel_size=1  ,activation=config.hidden_act  ,name="layer.0"   ),
               TFRegNetConvLayer(
                   UpperCAmelCase_  ,stride=UpperCAmelCase_  ,groups=UpperCAmelCase_  ,activation=config.hidden_act  ,name="layer.1"   ),
               TFRegNetConvLayer(UpperCAmelCase_  ,kernel_size=1  ,activation=UpperCAmelCase_  ,name="layer.2"   ),
           ]
           lowercase__									=    ACTaFN[config.hidden_act]







       def 				_a   (					self  ,UpperCAmelCase_   )	->				List[Any]:
           lowercase__									=    hidden_state
           for layer_module in self.layers:
               lowercase__									=    layer_module(UpperCAmelCase_   )
           lowercase__									=    self.shortcut(UpperCAmelCase_   )
           hidden_state += residual
           lowercase__									=    self.activation(UpperCAmelCase_   )
           return hidden_state





class 					snake_case			(tf.keras.layers.Layer ):



       def __init__(					self  ,UpperCAmelCase_  ,UpperCAmelCase_  ,UpperCAmelCase_  ,UpperCAmelCase_ = 1  ,**UpperCAmelCase_   )	->				List[str]:
           super().__init__(**UpperCAmelCase_   )
           lowercase__									=    in_channels != out_channels or stride != 1
           lowercase__									=    max(1  ,out_channels // config.groups_width   )
           lowercase__									=    (
               TFRegNetShortCut(UpperCAmelCase_  ,stride=UpperCAmelCase_  ,name="shortcut"   )
               if should_apply_shortcut
               else tf.keras.layers.Activation("linear"  ,name="shortcut"   )
           )
           lowercase__									=    [
               TFRegNetConvLayer(UpperCAmelCase_  ,kernel_size=1  ,activation=config.hidden_act  ,name="layer.0"   ),
               TFRegNetConvLayer(
                   UpperCAmelCase_  ,stride=UpperCAmelCase_  ,groups=UpperCAmelCase_  ,activation=config.hidden_act  ,name="layer.1"   ),
               TFRegNetSELayer(UpperCAmelCase_  ,reduced_channels=int(round(in_channels / 4   )   )  ,name="layer.2"   ),
               TFRegNetConvLayer(UpperCAmelCase_  ,kernel_size=1  ,activation=UpperCAmelCase_  ,name="layer.3"   ),
           ]
           lowercase__									=    ACTaFN[config.hidden_act]







       def 				_a   (					self  ,UpperCAmelCase_   )	->				Optional[int]:
           lowercase__									=    hidden_state
           for layer_module in self.layers:
               lowercase__									=    layer_module(UpperCAmelCase_   )
           lowercase__									=    self.shortcut(UpperCAmelCase_   )
           hidden_state += residual
           lowercase__									=    self.activation(UpperCAmelCase_   )
           return hidden_state





class 					snake_case			(tf.keras.layers.Layer ):



       def __init__(					self  ,UpperCAmelCase_  ,UpperCAmelCase_  ,UpperCAmelCase_  ,UpperCAmelCase_ = 2  ,UpperCAmelCase_ = 2  ,**UpperCAmelCase_   )	->				List[Any]:
           super().__init__(**UpperCAmelCase_   )

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







       def 				_a   (					self  ,UpperCAmelCase_   )	->				str:
           for layer_module in self.layers:
               lowercase__									=    layer_module(UpperCAmelCase_   )
           return hidden_state





class 					snake_case			(tf.keras.layers.Layer ):



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







       def 				_a   (					self  ,UpperCAmelCase_  ,UpperCAmelCase_ = False  ,UpperCAmelCase_ = True   )	->				TFBaseModelOutputWithNoAttention:
           lowercase__									=    () if output_hidden_states else None

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

               lowercase__									=    stage_module(UpperCAmelCase_   )

           if output_hidden_states:
               lowercase__									=    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=UpperCAmelCase_  ,hidden_states=UpperCAmelCase_   )





@keras_serializable
class 					snake_case			(tf.keras.layers.Layer ):
       lowerCAmelCase__	:Optional[int]     =       RegNetConfig



       def __init__(					self  ,UpperCAmelCase_  ,**UpperCAmelCase_   )	->				Optional[int]:
           super().__init__(**UpperCAmelCase_   )
           lowercase__									=    config
           lowercase__									=    TFRegNetEmbeddings(UpperCAmelCase_  ,name="embedder"   )
           lowercase__									=    TFRegNetEncoder(UpperCAmelCase_  ,name="encoder"   )
           lowercase__									=    tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCAmelCase_  ,name="pooler"   )







       @unpack_inputs
       def 				_a   (					self  ,UpperCAmelCase_  ,UpperCAmelCase_ = None  ,UpperCAmelCase_ = None  ,UpperCAmelCase_ = False  ,)	->				TFBaseModelOutputWithPoolingAndNoAttention:
           lowercase__									=    (
               output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
           )
           lowercase__									=    return_dict if return_dict is not None else self.config.use_return_dict

           lowercase__									=    self.embedder(UpperCAmelCase_  ,training=UpperCAmelCase_   )

           lowercase__									=    self.encoder(
               UpperCAmelCase_  ,output_hidden_states=UpperCAmelCase_  ,return_dict=UpperCAmelCase_  ,training=UpperCAmelCase_   )

           lowercase__									=    encoder_outputs[0]
           lowercase__									=    self.pooler(UpperCAmelCase_   )

           # Change to NCHW output format have uniformity in the modules
           lowercase__									=    tf.transpose(UpperCAmelCase_  ,perm=(0, 3, 1, 2)   )
           lowercase__									=    tf.transpose(UpperCAmelCase_  ,perm=(0, 3, 1, 2)   )

           # Change the other hidden state outputs to NCHW as well
           if output_hidden_states:
               lowercase__									=    tuple([tf.transpose(UpperCAmelCase_  ,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=UpperCAmelCase_  ,pooler_output=UpperCAmelCase_  ,hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states  ,)





class 					snake_case			(UpperCamelCase ):
       lowerCAmelCase__	:Tuple     =       RegNetConfig
       lowerCAmelCase__	:Tuple     =       "regnet"
       lowerCAmelCase__	:Optional[int]     =       "pixel_values"



       @property
       def 				_a   (					self   )	->				List[Any]:
           return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)  ,dtype=tf.floataa   )}





SCREAMING_SNAKE_CASE__          =  R"\n    Parameters:\n    This model is a Tensorflow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and\n    behavior.\n        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n"

SCREAMING_SNAKE_CASE__          =  R"\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConveNextImageProcessor.__call__`] for details.\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"


@add_start_docstrings(
    "The bare RegNet model outputting raw features without any specific head on top."		,   UpperCamelCase		,   )
class 					snake_case			(UpperCamelCase ):



       def __init__(					self  ,UpperCAmelCase_  ,*UpperCAmelCase_  ,**UpperCAmelCase_   )	->				Any:
           super().__init__(UpperCAmelCase_  ,*UpperCAmelCase_  ,**UpperCAmelCase_   )
           lowercase__									=    TFRegNetMainLayer(UpperCAmelCase_  ,name="regnet"   )







       @unpack_inputs
       @add_start_docstrings_to_model_forward(UpperCAmelCase_   )
       @add_code_sample_docstrings(
           checkpoint=_CHECKPOINT_FOR_DOC  ,output_type=UpperCAmelCase_  ,config_class=_CONFIG_FOR_DOC  ,modality="vision"  ,expected_output=_EXPECTED_OUTPUT_SHAPE  ,)
       def 				_a   (					self  ,UpperCAmelCase_  ,UpperCAmelCase_ = None  ,UpperCAmelCase_ = None  ,UpperCAmelCase_=False  ,)	->				Union[TFBaseModelOutputWithPoolingAndNoAttention, Tuple[tf.Tensor]]:
           lowercase__									=    (
               output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
           )
           lowercase__									=    return_dict if return_dict is not None else self.config.use_return_dict

           lowercase__									=    self.regnet(
               pixel_values=UpperCAmelCase_  ,output_hidden_states=UpperCAmelCase_  ,return_dict=UpperCAmelCase_  ,training=UpperCAmelCase_  ,)
           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    "		,   UpperCamelCase		,   )
class 					snake_case			(UpperCamelCase		,   UpperCamelCase ):



       def __init__(					self  ,UpperCAmelCase_  ,*UpperCAmelCase_  ,**UpperCAmelCase_   )	->				str:
           super().__init__(UpperCAmelCase_  ,*UpperCAmelCase_  ,**UpperCAmelCase_   )
           lowercase__									=    config.num_labels
           lowercase__									=    TFRegNetMainLayer(UpperCAmelCase_  ,name="regnet"   )
           # classification head
           lowercase__									=    [
               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(UpperCAmelCase_   )
       @add_code_sample_docstrings(
           checkpoint=_IMAGE_CLASS_CHECKPOINT  ,output_type=UpperCAmelCase_  ,config_class=_CONFIG_FOR_DOC  ,expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT  ,)
       def 				_a   (					self  ,UpperCAmelCase_ = None  ,UpperCAmelCase_ = None  ,UpperCAmelCase_ = None  ,UpperCAmelCase_ = None  ,UpperCAmelCase_=False  ,)	->				Union[TFSequenceClassifierOutput, Tuple[tf.Tensor]]:
           lowercase__									=    (
               output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
           )
           lowercase__									=    return_dict if return_dict is not None else self.config.use_return_dict

           lowercase__									=    self.regnet(
               UpperCAmelCase_  ,output_hidden_states=UpperCAmelCase_  ,return_dict=UpperCAmelCase_  ,training=UpperCAmelCase_   )

           lowercase__									=    outputs.pooler_output if return_dict else outputs[1]

           lowercase__									=    self.classifier[0](UpperCAmelCase_   )
           lowercase__									=    self.classifier[1](UpperCAmelCase_   )

           lowercase__									=    None if labels is None else self.hf_compute_loss(labels=UpperCAmelCase_  ,logits=UpperCAmelCase_   )

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

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









'''simple docstring'''





import json
from typing import Iterator, List, Union

from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, trainers
from tokenizers.implementations.base_tokenizer import BaseTokenizer
from tokenizers.models import Unigram
from tokenizers.processors import TemplateProcessing


class 					snake_case			(UpperCamelCase ):



       def __init__(					self  ,UpperCAmelCase_ = "▁"  ,UpperCAmelCase_ = True  ,UpperCAmelCase_ = "<unk>"  ,UpperCAmelCase_ = "</s>"  ,UpperCAmelCase_ = "<pad>"  ,)	->				Optional[int]:
           lowercase__									=    {
               "pad": {"id": 0, "token": pad_token},
               "eos": {"id": 1, "token": eos_token},
               "unk": {"id": 2, "token": unk_token},
           }

           lowercase__									=    [None] * len(self.special_tokens   )
           for token_dict in self.special_tokens.values():
               lowercase__									=    token_dict["token"]

           lowercase__									=    Tokenizer(Unigram()   )

           lowercase__									=    normalizers.Sequence(
               [
                   normalizers.Nmt(),
                   normalizers.NFKC(),
                   normalizers.Replace(Regex(" {2,}"   )  ," "   ),
                   normalizers.Lowercase(),
               ]   )
           lowercase__									=    pre_tokenizers.Sequence(
               [
                   pre_tokenizers.Metaspace(replacement=UpperCAmelCase_  ,add_prefix_space=UpperCAmelCase_   ),
                   pre_tokenizers.Digits(individual_digits=UpperCAmelCase_   ),
                   pre_tokenizers.Punctuation(),
               ]   )
           lowercase__									=    decoders.Metaspace(replacement=UpperCAmelCase_  ,add_prefix_space=UpperCAmelCase_   )

           lowercase__									=    TemplateProcessing(
               single=F'''$A {self.special_tokens['eos']['token']}'''  ,special_tokens=[(self.special_tokens["eos"]["token"], self.special_tokens["eos"]["id"])]  ,)

           lowercase__									=    {
               "model": "SentencePieceUnigram",
               "replacement": replacement,
               "add_prefix_space": add_prefix_space,
           }

           super().__init__(UpperCAmelCase_  ,UpperCAmelCase_   )



       def 				_a   (					self  ,UpperCAmelCase_  ,UpperCAmelCase_ = 8_000  ,UpperCAmelCase_ = True  ,)	->				List[str]:
           lowercase__									=    trainers.UnigramTrainer(
               vocab_size=UpperCAmelCase_  ,special_tokens=self.special_tokens_list  ,show_progress=UpperCAmelCase_  ,)

           if isinstance(UpperCAmelCase_  ,UpperCAmelCase_   ):
               lowercase__									=    [files]
           self._tokenizer.train(UpperCAmelCase_  ,trainer=UpperCAmelCase_   )

           self.add_unk_id()



       def 				_a   (					self  ,UpperCAmelCase_  ,UpperCAmelCase_ = 8_000  ,UpperCAmelCase_ = True  ,)	->				Union[str, Any]:
           lowercase__									=    trainers.UnigramTrainer(
               vocab_size=UpperCAmelCase_  ,special_tokens=self.special_tokens_list  ,show_progress=UpperCAmelCase_  ,)

           self._tokenizer.train_from_iterator(UpperCAmelCase_  ,trainer=UpperCAmelCase_   )

           self.add_unk_id()







       def 				_a   (					self   )	->				str:
           lowercase__									=    json.loads(self._tokenizer.to_str()   )

           lowercase__									=    self.special_tokens["unk"]["id"]

           lowercase__									=    Tokenizer.from_str(json.dumps(UpperCAmelCase_   )   )




