






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


snake_case__   :						int													=   logging.get_logger(__name__)

# General docstring
snake_case__   :						List[str]													=   """RegNetConfig"""

# Base docstring
snake_case__   :						Any													=   """facebook/regnet-y-040"""
snake_case__   :						Any													=   [1, 1_0_8_8, 7, 7]

# Image classification docstring
snake_case__   :						List[Any]													=   """facebook/regnet-y-040"""
snake_case__   :						Union[str, Any]													=   """tabby, tabby cat"""

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


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






  """simple docstring"""





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




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			str:
     UpperCamelCase_						=  self.convolution(self.padding(_UpperCAmelCase			)			)
     UpperCamelCase_						=  self.normalization(_UpperCAmelCase			)
     UpperCamelCase_						=  self.activation(_UpperCAmelCase			)
     return hidden_state




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






  """simple docstring"""





  def __init__(  self		,		_UpperCAmelCase		,		**_UpperCAmelCase			)      ->			Any:
     super().__init__(**_UpperCAmelCase			)
     UpperCamelCase_						=  config.num_channels
     UpperCamelCase_						=  TFRegNetConvLayer(
         out_channels=config.embedding_size		,		kernel_size=3		,		stride=2		,		activation=config.hidden_act		,		name='embedder'		,		)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Optional[int]:
     UpperCamelCase_						=  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)
     UpperCamelCase_						=  tf.transpose(_UpperCAmelCase		,		perm=(0, 2, 3, 1)			)
     UpperCamelCase_						=  self.embedder(_UpperCAmelCase			)
     return hidden_state




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






  """simple docstring"""





  def __init__(  self		,		_UpperCAmelCase		,		_UpperCAmelCase = 2		,		**_UpperCAmelCase			)      ->			Union[str, Any]:
     super().__init__(**_UpperCAmelCase			)
     UpperCamelCase_						=  tf.keras.layers.ConvaD(
         filters=_UpperCAmelCase		,		kernel_size=1		,		strides=_UpperCAmelCase		,		use_bias=_UpperCAmelCase		,		name='convolution'			)
     UpperCamelCase_						=  tf.keras.layers.BatchNormalization(epsilon=1e-5		,		momentum=0.9		,		name='normalization'			)




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




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






  """simple docstring"""





  def __init__(  self		,		_UpperCAmelCase		,		_UpperCAmelCase		,		**_UpperCAmelCase			)      ->			List[str]:
     super().__init__(**_UpperCAmelCase			)
     UpperCamelCase_						=  tf.keras.layers.GlobalAveragePoolingaD(keepdims=_UpperCAmelCase		,		name='pooler'			)
     UpperCamelCase_						=  [
         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  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			str:
     # [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
     UpperCamelCase_						=  self.pooler(_UpperCAmelCase			)
     for layer_module in self.attention:
        UpperCamelCase_						=  layer_module(_UpperCAmelCase			)
     UpperCamelCase_						=  hidden_state * pooled
     return hidden_state




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






  """simple docstring"""





  def __init__(  self		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase = 1		,		**_UpperCAmelCase			)      ->			List[str]:
     super().__init__(**_UpperCAmelCase			)
     UpperCamelCase_						=  in_channels != out_channels or stride != 1
     UpperCamelCase_						=  max(1		,		out_channels // config.groups_width			)
     UpperCamelCase_						=  (
         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.
     UpperCamelCase_						=  [
         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'			),
     ]
     UpperCamelCase_						=  ACTaFN[config.hidden_act]




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Tuple:
     UpperCamelCase_						=  hidden_state
     for layer_module in self.layers:
        UpperCamelCase_						=  layer_module(_UpperCAmelCase			)
     UpperCamelCase_						=  self.shortcut(_UpperCAmelCase			)
     hidden_state += residual
     UpperCamelCase_						=  self.activation(_UpperCAmelCase			)
     return hidden_state




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






  """simple docstring"""





  def __init__(  self		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase = 1		,		**_UpperCAmelCase			)      ->			Optional[int]:
     super().__init__(**_UpperCAmelCase			)
     UpperCamelCase_						=  in_channels != out_channels or stride != 1
     UpperCamelCase_						=  max(1		,		out_channels // config.groups_width			)
     UpperCamelCase_						=  (
         TFRegNetShortCut(_UpperCAmelCase		,		stride=_UpperCAmelCase		,		name='shortcut'			)
         if should_apply_shortcut
         else tf.keras.layers.Activation('linear'		,		name='shortcut'			)
     )
     UpperCamelCase_						=  [
         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'			),
     ]
     UpperCamelCase_						=  ACTaFN[config.hidden_act]




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Tuple:
     UpperCamelCase_						=  hidden_state
     for layer_module in self.layers:
        UpperCamelCase_						=  layer_module(_UpperCAmelCase			)
     UpperCamelCase_						=  self.shortcut(_UpperCAmelCase			)
     hidden_state += residual
     UpperCamelCase_						=  self.activation(_UpperCAmelCase			)
     return hidden_state




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






  """simple docstring"""





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

     UpperCamelCase_						=  TFRegNetXLayer if config.layer_type == 'x' else TFRegNetYLayer
     UpperCamelCase_						=  [
         # 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  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Union[str, Any]:
     for layer_module in self.layers:
        UpperCamelCase_						=  layer_module(_UpperCAmelCase			)
     return hidden_state




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






  """simple docstring"""





  def __init__(  self		,		_UpperCAmelCase		,		**_UpperCAmelCase			)      ->			str:
     super().__init__(**_UpperCAmelCase			)
     UpperCamelCase_						=  []
     # 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'		,		)			)
     UpperCamelCase_						=  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  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase = False		,		_UpperCAmelCase = True			)      ->			TFBaseModelOutputWithNoAttention:
     UpperCamelCase_						=  () if output_hidden_states else None

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

        UpperCamelCase_						=  stage_module(_UpperCAmelCase			)

     if output_hidden_states:
        UpperCamelCase_						=  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     _a							(	tf.keras.layers.Layer     ):






  """simple docstring"""





  A_						       = RegNetConfig




  def __init__(  self		,		_UpperCAmelCase		,		**_UpperCAmelCase			)      ->			Tuple:
     super().__init__(**_UpperCAmelCase			)
     UpperCamelCase_						=  config
     UpperCamelCase_						=  TFRegNetEmbeddings(_UpperCAmelCase		,		name='embedder'			)
     UpperCamelCase_						=  TFRegNetEncoder(_UpperCAmelCase		,		name='encoder'			)
     UpperCamelCase_						=  tf.keras.layers.GlobalAveragePoolingaD(keepdims=_UpperCAmelCase		,		name='pooler'			)




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

     UpperCamelCase_						=  self.embedder(_UpperCAmelCase		,		training=_UpperCAmelCase			)

     UpperCamelCase_						=  self.encoder(
         _UpperCAmelCase		,		output_hidden_states=_UpperCAmelCase		,		return_dict=_UpperCAmelCase		,		training=_UpperCAmelCase			)

     UpperCamelCase_						=  encoder_outputs[0]
     UpperCamelCase_						=  self.pooler(_UpperCAmelCase			)

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

     # Change the other hidden state outputs to NCHW as well
     if output_hidden_states:
        UpperCamelCase_						=  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     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  A_						       = RegNetConfig
  A_						       = """regnet"""
  A_						       = """pixel_values"""




  @property
  def  _UpperCAmelCase  (  self			)      ->			Tuple:
     return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)		,		dtype=tf.floataa			)}




snake_case__   :						Dict													=   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.
"""

snake_case__   :						Optional[Any]													=   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."""    ,							UpperCAmelCase__    ,							)
class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  def __init__(  self		,		_UpperCAmelCase		,		*_UpperCAmelCase		,		**_UpperCAmelCase			)      ->			List[Any]:
     super().__init__(_UpperCAmelCase		,		*_UpperCAmelCase		,		**_UpperCAmelCase			)
     UpperCamelCase_						=  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  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase = None		,		_UpperCAmelCase = None		,		_UpperCAmelCase=False		,		)      ->			Union[TFBaseModelOutputWithPoolingAndNoAttention, Tuple[tf.Tensor]]:
     UpperCamelCase_						=  (
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     UpperCamelCase_						=  return_dict if return_dict is not None else self.config.use_return_dict

     UpperCamelCase_						=  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(
    """
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """    ,							UpperCAmelCase__    ,							)
class     _a							(	UpperCAmelCase__    ,							UpperCAmelCase__     ):






  """simple docstring"""





  def __init__(  self		,		_UpperCAmelCase		,		*_UpperCAmelCase		,		**_UpperCAmelCase			)      ->			List[Any]:
     super().__init__(_UpperCAmelCase		,		*_UpperCAmelCase		,		**_UpperCAmelCase			)
     UpperCamelCase_						=  config.num_labels
     UpperCamelCase_						=  TFRegNetMainLayer(_UpperCAmelCase		,		name='regnet'			)
     # classification head
     UpperCamelCase_						=  [
         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  _UpperCAmelCase  (  self		,		_UpperCAmelCase = None		,		_UpperCAmelCase = None		,		_UpperCAmelCase = None		,		_UpperCAmelCase = None		,		_UpperCAmelCase=False		,		)      ->			Union[TFSequenceClassifierOutput, Tuple[tf.Tensor]]:
     UpperCamelCase_						=  (
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     UpperCamelCase_						=  return_dict if return_dict is not None else self.config.use_return_dict

     UpperCamelCase_						=  self.regnet(
         _UpperCAmelCase		,		output_hidden_states=_UpperCAmelCase		,		return_dict=_UpperCAmelCase		,		training=_UpperCAmelCase			)

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

     UpperCamelCase_						=  self.classifier[0](_UpperCAmelCase			)
     UpperCamelCase_						=  self.classifier[1](_UpperCAmelCase			)

     UpperCamelCase_						=  None if labels is None else self.hf_compute_loss(labels=_UpperCAmelCase		,		logits=_UpperCAmelCase			)

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

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













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     ):






  """simple docstring"""





  A_						       = MODEL_FOR_MASKED_LM_MAPPING
  A_						       = TF_MODEL_FOR_MASKED_LM_MAPPING




  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     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			)      ->			str:
     UpperCamelCase_						=  pipeline(task='fill-mask'		,		model='sshleifer/tiny-distilroberta-base'		,		top_k=2		,		framework='tf'			)
     UpperCamelCase_						=  unmasker('My name is <mask>'			)
     self.assertEqual(
         nested_simplify(_UpperCAmelCase		,		decimals=6			)		,		[
             {'sequence': 'My name is grouped', 'score': 2.1e-05, 'token': 38015, 'token_str': ' grouped'},
             {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 25506, 'token_str': ' accuser'},
         ]		,		)

     UpperCamelCase_						=  unmasker('The largest city in France is <mask>'			)
     self.assertEqual(
         nested_simplify(_UpperCAmelCase		,		decimals=6			)		,		[
             {
                 'sequence': 'The largest city in France is grouped',
                 'score': 2.1e-05,
                 'token': 38015,
                 'token_str': ' grouped',
             },
             {
                 'sequence': 'The largest city in France is accuser',
                 'score': 2.1e-05,
                 'token': 25506,
                 'token_str': ' accuser',
             },
         ]		,		)

     UpperCamelCase_						=  unmasker('My name is <mask>'		,		targets=[' Patrick', ' Clara', ' Teven']		,		top_k=3			)
     self.assertEqual(
         nested_simplify(_UpperCAmelCase		,		decimals=6			)		,		[
             {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 13606, '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			)      ->			Union[str, Any]:
     UpperCamelCase_						=  pipeline(task='fill-mask'		,		model='sshleifer/tiny-distilroberta-base'		,		top_k=2		,		framework='pt'			)

     UpperCamelCase_						=  unmasker('My name is <mask>'			)
     self.assertEqual(
         nested_simplify(_UpperCAmelCase		,		decimals=6			)		,		[
             {'sequence': 'My name is Maul', 'score': 2.2e-05, 'token': 35676, 'token_str': ' Maul'},
             {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'},
         ]		,		)

     UpperCamelCase_						=  unmasker('The largest city in France is <mask>'			)
     self.assertEqual(
         nested_simplify(_UpperCAmelCase		,		decimals=6			)		,		[
             {
                 'sequence': 'The largest city in France is Maul',
                 'score': 2.2e-05,
                 'token': 35676,
                 'token_str': ' Maul',
             },
             {'sequence': 'The largest city in France isELS', 'score': 2.2e-05, 'token': 16416, 'token_str': 'ELS'},
         ]		,		)

     UpperCamelCase_						=  unmasker('My name is <mask>'		,		targets=[' Patrick', ' Clara', ' Teven']		,		top_k=3			)
     self.assertEqual(
         nested_simplify(_UpperCAmelCase		,		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': 13606, 'token_str': ' Clara'},
         ]		,		)

     UpperCamelCase_						=  unmasker('My name is <mask> <mask>'		,		top_k=2			)

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




  @require_torch_gpu
  def  _UpperCAmelCase  (  self			)      ->			Optional[Any]:
     UpperCamelCase_						=  pipeline('fill-mask'		,		model='hf-internal-testing/tiny-random-distilbert'		,		device=0		,		framework='pt'			)

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

     UpperCamelCase_						=  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(_UpperCAmelCase		,		_UpperCAmelCase			)




  @slow
  @require_torch
  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     UpperCamelCase_						=  pipeline(task='fill-mask'		,		model='distilroberta-base'		,		top_k=2		,		framework='pt'			)
     self.run_large_test(_UpperCAmelCase			)




  @slow
  @require_tf
  def  _UpperCAmelCase  (  self			)      ->			Union[str, Any]:
     UpperCamelCase_						=  pipeline(task='fill-mask'		,		model='distilroberta-base'		,		top_k=2		,		framework='tf'			)
     self.run_large_test(_UpperCAmelCase			)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			Tuple:
     UpperCamelCase_						=  unmasker('My name is <mask>'			)
     self.assertEqual(
         nested_simplify(_UpperCAmelCase			)		,		[
             {'sequence': 'My name is John', 'score': 0.0_0_8, 'token': 610, 'token_str': ' John'},
             {'sequence': 'My name is Chris', 'score': 0.0_0_7, 'token': 1573, 'token_str': ' Chris'},
         ]		,		)
     UpperCamelCase_						=  unmasker('The largest city in France is <mask>'			)
     self.assertEqual(
         nested_simplify(_UpperCAmelCase			)		,		[
             {
                 'sequence': 'The largest city in France is Paris',
                 'score': 0.2_5_1,
                 'token': 2201,
                 'token_str': ' Paris',
             },
             {
                 'sequence': 'The largest city in France is Lyon',
                 'score': 0.2_1_4,
                 'token': 12790,
                 'token_str': ' Lyon',
             },
         ]		,		)

     UpperCamelCase_						=  unmasker('My name is <mask>'		,		targets=[' Patrick', ' Clara', ' Teven']		,		top_k=3			)
     self.assertEqual(
         nested_simplify(_UpperCAmelCase			)		,		[
             {'sequence': 'My name is Patrick', 'score': 0.0_0_5, 'token': 3499, 'token_str': ' Patrick'},
             {'sequence': 'My name is Clara', 'score': 0.0_0_0, 'token': 13606, 'token_str': ' Clara'},
             {'sequence': 'My name is Te', 'score': 0.0_0_0, 'token': 2941, 'token_str': ' Te'},
         ]		,		)




  @require_torch
  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     UpperCamelCase_						=  pipeline(task='fill-mask'		,		model='sshleifer/tiny-distilroberta-base'		,		framework='pt'			)
     UpperCamelCase_						=  None
     UpperCamelCase_						=  None
     self.run_pipeline_test(_UpperCAmelCase		,		[]			)




  @require_tf
  def  _UpperCAmelCase  (  self			)      ->			Optional[int]:
     UpperCamelCase_						=  pipeline(task='fill-mask'		,		model='sshleifer/tiny-distilroberta-base'		,		framework='tf'			)
     UpperCamelCase_						=  None
     UpperCamelCase_						=  None
     self.run_pipeline_test(_UpperCAmelCase		,		[]			)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Optional[Any]:
     if tokenizer is None or tokenizer.mask_token_id is None:
        self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)'			)

     UpperCamelCase_						=  FillMaskPipeline(model=_UpperCAmelCase		,		tokenizer=_UpperCAmelCase			)
     UpperCamelCase_						=  [
         f"""This is another {tokenizer.mask_token} test""",
     ]
     return fill_masker, examples




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Union[str, Any]:
     UpperCamelCase_						=  fill_masker.tokenizer
     UpperCamelCase_						=  fill_masker.model

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

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

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

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

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




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

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

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

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




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Tuple:
     UpperCamelCase_						=  FillMaskPipeline(model=_UpperCAmelCase		,		tokenizer=_UpperCAmelCase		,		top_k=2			)
     UpperCamelCase_						=  fill_masker(f"""This is a {tokenizer.mask_token}"""			)
     self.assertEqual(
         _UpperCAmelCase		,		[
             {'sequence': ANY(_UpperCAmelCase			), 'score': ANY(_UpperCAmelCase			), 'token': ANY(_UpperCAmelCase			), 'token_str': ANY(_UpperCAmelCase			)},
             {'sequence': ANY(_UpperCAmelCase			), 'score': ANY(_UpperCAmelCase			), 'token': ANY(_UpperCAmelCase			), 'token_str': ANY(_UpperCAmelCase			)},
         ]		,		)

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




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			List[Any]:
     UpperCamelCase_						=  tokenizer.get_vocab()
     UpperCamelCase_						=  FillMaskPipeline(model=_UpperCAmelCase		,		tokenizer=_UpperCAmelCase			)

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

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




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			Optional[int]:
     UpperCamelCase_						=  FillMaskPipeline(model=_UpperCAmelCase		,		tokenizer=_UpperCAmelCase			)
     UpperCamelCase_						=  tokenizer.get_vocab()
     # String duplicates + id duplicates
     UpperCamelCase_						=  sorted(vocab.keys()			)[:3]
     UpperCamelCase_						=  [targets[0], targets[1], targets[0], targets[2], targets[1]]
     UpperCamelCase_						=  fill_masker(f"""My name is {tokenizer.mask_token}"""		,		targets=_UpperCAmelCase		,		top_k=10			)

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




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			List[str]:
     UpperCamelCase_						=  FillMaskPipeline(model=_UpperCAmelCase		,		tokenizer=_UpperCAmelCase			)

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





