




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


UpperCAmelCase_					=   logging.get_logger(__name__)

# General docstring
UpperCAmelCase_					=   "RegNetConfig"

# Base docstring
UpperCAmelCase_					=   "facebook/regnet-y-040"
UpperCAmelCase_					=   [1, 10_88, 7, 7]

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

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





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







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







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     int:
     __a								=       self.convolution(self.padding(UpperCamelCase   )   )
     __a								=       self.normalization(UpperCamelCase   )
     __a								=       self.activation(UpperCamelCase   )
     return hidden_state





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







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







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





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







   def __init__(						self   ,				UpperCamelCase   ,				UpperCamelCase = 2   ,				**UpperCamelCase   )					->     List[str]:
     super().__init__(**UpperCamelCase   )
     __a								=       tf.keras.layers.ConvaD(
         filters=UpperCamelCase   ,				kernel_size=1   ,				strides=UpperCamelCase   ,				use_bias=UpperCamelCase   ,				name='convolution'   )
     __a								=       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  __lowercase    (	tf.keras.layers.Layer			):







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





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







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







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Dict:
     __a								=       hidden_state
     for layer_module in self.layers:
       __a								=       layer_module(UpperCamelCase   )
     __a								=       self.shortcut(UpperCamelCase   )
     hidden_state += residual
     __a								=       self.activation(UpperCamelCase   )
     return hidden_state





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







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







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Dict:
     __a								=       hidden_state
     for layer_module in self.layers:
       __a								=       layer_module(UpperCamelCase   )
     __a								=       self.shortcut(UpperCamelCase   )
     hidden_state += residual
     __a								=       self.activation(UpperCamelCase   )
     return hidden_state





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







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

     __a								=       TFRegNetXLayer if config.layer_type == 'x' else TFRegNetYLayer
     __a								=       [
         # 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   )					->     str:
     for layer_module in self.layers:
       __a								=       layer_module(UpperCamelCase   )
     return hidden_state





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







   def __init__(						self   ,				UpperCamelCase   ,				**UpperCamelCase   )					->     List[str]:
     super().__init__(**UpperCamelCase   )
     __a								=       []
     # 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'   ,				)   )
     __a								=       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:
     __a								=       () if output_hidden_states else None

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

       __a								=       stage_module(UpperCamelCase   )

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







   def __init__(						self   ,				UpperCamelCase   ,				**UpperCamelCase   )					->     List[str]:
     super().__init__(**UpperCamelCase   )
     __a								=       config
     __a								=       TFRegNetEmbeddings(UpperCamelCase   ,				name='embedder'   )
     __a								=       TFRegNetEncoder(UpperCamelCase   ,				name='encoder'   )
     __a								=       tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCamelCase   ,				name='pooler'   )







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

     __a								=       self.embedder(UpperCamelCase   ,				training=UpperCamelCase   )

     __a								=       self.encoder(
         UpperCamelCase   ,				output_hidden_states=UpperCamelCase   ,				return_dict=UpperCamelCase   ,				training=UpperCamelCase   )

     __a								=       encoder_outputs[0]
     __a								=       self.pooler(UpperCamelCase   )

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

     # Change the other hidden state outputs to NCHW as well
     if output_hidden_states:
       __a								=       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  __lowercase    (	__magic_name__			):
   _a    						=   RegNetConfig
   _a    						=   """regnet"""
   _a    						=   """pixel_values"""







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

UpperCAmelCase_					=   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"

UpperCAmelCase_					=   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."""							,				__magic_name__							,				)
class  __lowercase    (	__magic_name__			):







   def __init__(						self   ,				UpperCamelCase   ,				*UpperCamelCase   ,				**UpperCamelCase   )					->     Optional[int]:
     super().__init__(UpperCamelCase   ,				*UpperCamelCase   ,				**UpperCamelCase   )
     __a								=       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]]:
     __a								=       (
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     __a								=       return_dict if return_dict is not None else self.config.use_return_dict

     __a								=       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.
    """							,				__magic_name__							,				)
class  __lowercase    (	__magic_name__							,				__magic_name__			):







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

     __a								=       self.regnet(
         UpperCamelCase   ,				output_hidden_states=UpperCamelCase   ,				return_dict=UpperCamelCase   ,				training=UpperCamelCase   )

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

     __a								=       self.classifier[0](UpperCamelCase   )
     __a								=       self.classifier[1](UpperCamelCase   )

     __a								=       None if labels is None else self.hf_compute_loss(labels=UpperCamelCase   ,				logits=UpperCamelCase   )

     if not return_dict:
       __a								=       (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 unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
UpperCAmelCase_					=   {"LayoutLMv2Config", "LayoutLMv3Config"}





@is_pipeline_test
class  __lowercase    (	unittest.TestCase			):
   _a    						=   MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
   _a    						=   TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

   if model_mapping is not None:
      _a    						=   {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
   if tf_model_mapping is not None:
      _a    						=   {
          config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
      }







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )					->     Optional[Any]:
     __a								=       ZeroShotClassificationPipeline(
         model=UpperCamelCase   ,				tokenizer=UpperCamelCase   ,				candidate_labels=['polics', 'health']   )
     return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     Tuple:
     __a								=       classifier('Who are you voting for in 2020?'   ,				candidate_labels='politics'   )
     self.assertEqual(UpperCamelCase   ,				{'sequence': ANY(UpperCamelCase   ), 'labels': [ANY(UpperCamelCase   )], 'scores': [ANY(UpperCamelCase   )]}   )

     # No kwarg
     __a								=       classifier('Who are you voting for in 2020?'   ,				['politics']   )
     self.assertEqual(UpperCamelCase   ,				{'sequence': ANY(UpperCamelCase   ), 'labels': [ANY(UpperCamelCase   )], 'scores': [ANY(UpperCamelCase   )]}   )

     __a								=       classifier('Who are you voting for in 2020?'   ,				candidate_labels=['politics']   )
     self.assertEqual(UpperCamelCase   ,				{'sequence': ANY(UpperCamelCase   ), 'labels': [ANY(UpperCamelCase   )], 'scores': [ANY(UpperCamelCase   )]}   )

     __a								=       classifier('Who are you voting for in 2020?'   ,				candidate_labels='politics, public health'   )
     self.assertEqual(
         UpperCamelCase   ,				{'sequence': ANY(UpperCamelCase   ), 'labels': [ANY(UpperCamelCase   ), ANY(UpperCamelCase   )], 'scores': [ANY(UpperCamelCase   ), ANY(UpperCamelCase   )]}   )
     self.assertAlmostEqual(sum(nested_simplify(outputs['scores']   )   )   ,				1.0   )

     __a								=       classifier('Who are you voting for in 2020?'   ,				candidate_labels=['politics', 'public health']   )
     self.assertEqual(
         UpperCamelCase   ,				{'sequence': ANY(UpperCamelCase   ), 'labels': [ANY(UpperCamelCase   ), ANY(UpperCamelCase   )], 'scores': [ANY(UpperCamelCase   ), ANY(UpperCamelCase   )]}   )
     self.assertAlmostEqual(sum(nested_simplify(outputs['scores']   )   )   ,				1.0   )

     __a								=       classifier(
         'Who are you voting for in 2020?'   ,				candidate_labels='politics'   ,				hypothesis_template='This text is about {}'   )
     self.assertEqual(UpperCamelCase   ,				{'sequence': ANY(UpperCamelCase   ), 'labels': [ANY(UpperCamelCase   )], 'scores': [ANY(UpperCamelCase   )]}   )

     # https://github.com/huggingface/transformers/issues/13846
     __a								=       classifier(['I am happy']   ,				['positive', 'negative']   )
     self.assertEqual(
         UpperCamelCase   ,				[
             {'sequence': ANY(UpperCamelCase   ), 'labels': [ANY(UpperCamelCase   ), ANY(UpperCamelCase   )], 'scores': [ANY(UpperCamelCase   ), ANY(UpperCamelCase   )]}
             for i in range(1   )
         ]   ,				)
     __a								=       classifier(['I am happy', 'I am sad']   ,				['positive', 'negative']   )
     self.assertEqual(
         UpperCamelCase   ,				[
             {'sequence': ANY(UpperCamelCase   ), 'labels': [ANY(UpperCamelCase   ), ANY(UpperCamelCase   )], 'scores': [ANY(UpperCamelCase   ), ANY(UpperCamelCase   )]}
             for i in range(2   )
         ]   ,				)

     with self.assertRaises(UpperCamelCase   ):
       classifier(''   ,				candidate_labels='politics'   )

     with self.assertRaises(UpperCamelCase   ):
       classifier(UpperCamelCase   ,				candidate_labels='politics'   )

     with self.assertRaises(UpperCamelCase   ):
       classifier('Who are you voting for in 2020?'   ,				candidate_labels=''   )

     with self.assertRaises(UpperCamelCase   ):
       classifier('Who are you voting for in 2020?'   ,				candidate_labels=UpperCamelCase   )

     with self.assertRaises(UpperCamelCase   ):
       classifier(
           'Who are you voting for in 2020?'   ,				candidate_labels='politics'   ,				hypothesis_template='Not formatting template'   ,				)

     with self.assertRaises(UpperCamelCase   ):
       classifier(
           'Who are you voting for in 2020?'   ,				candidate_labels='politics'   ,				hypothesis_template=UpperCamelCase   ,				)

     self.run_entailment_id(UpperCamelCase   )







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Optional[int]:
     __a								=       zero_shot_classifier.model.config
     __a								=       config.labelaid
     __a								=       zero_shot_classifier.entailment_id

     __a								=       {'LABEL_0': 0, 'LABEL_1': 1, 'LABEL_2': 2}
     self.assertEqual(zero_shot_classifier.entailment_id   ,				-1   )

     __a								=       {'entailment': 0, 'neutral': 1, 'contradiction': 2}
     self.assertEqual(zero_shot_classifier.entailment_id   ,				0   )

     __a								=       {'ENTAIL': 0, 'NON-ENTAIL': 1}
     self.assertEqual(zero_shot_classifier.entailment_id   ,				0   )

     __a								=       {'ENTAIL': 2, 'NEUTRAL': 1, 'CONTR': 0}
     self.assertEqual(zero_shot_classifier.entailment_id   ,				2   )

     __a								=       original_labelaid
     self.assertEqual(UpperCamelCase   ,				zero_shot_classifier.entailment_id   )







   @require_torch
   def 		UpperCamelCase__      (						self   )					->     Tuple:
     __a								=       pipeline(
         'zero-shot-classification'   ,				model='sshleifer/tiny-distilbert-base-cased-distilled-squad'   ,				framework='pt'   ,				)
     # There was a regression in 4.10 for this
     # Adding a test so we don't make the mistake again.
     # https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
     zero_shot_classifier(
         'Who are you voting for in 2020?' * 100   ,				candidate_labels=['politics', 'public health', 'science']   )







   @require_torch
   def 		UpperCamelCase__      (						self   )					->     List[str]:
     __a								=       pipeline(
         'zero-shot-classification'   ,				model='sshleifer/tiny-distilbert-base-cased-distilled-squad'   ,				framework='pt'   ,				)
     __a								=       zero_shot_classifier(
         'Who are you voting for in 2020?'   ,				candidate_labels=['politics', 'public health', 'science']   )

     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				{
             'sequence': 'Who are you voting for in 2020?',
             'labels': ['science', 'public health', 'politics'],
             'scores': [0.333, 0.333, 0.333],
         }   ,				)







   @require_tf
   def 		UpperCamelCase__      (						self   )					->     Dict:
     __a								=       pipeline(
         'zero-shot-classification'   ,				model='sshleifer/tiny-distilbert-base-cased-distilled-squad'   ,				framework='tf'   ,				)
     __a								=       zero_shot_classifier(
         'Who are you voting for in 2020?'   ,				candidate_labels=['politics', 'public health', 'science']   )

     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				{
             'sequence': 'Who are you voting for in 2020?',
             'labels': ['science', 'public health', 'politics'],
             'scores': [0.333, 0.333, 0.333],
         }   ,				)







   @slow
   @require_torch
   def 		UpperCamelCase__      (						self   )					->     List[str]:
     __a								=       pipeline('zero-shot-classification'   ,				model='roberta-large-mnli'   ,				framework='pt'   )
     __a								=       zero_shot_classifier(
         'Who are you voting for in 2020?'   ,				candidate_labels=['politics', 'public health', 'science']   )

     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				{
             'sequence': 'Who are you voting for in 2020?',
             'labels': ['politics', 'public health', 'science'],
             'scores': [0.976, 0.015, 0.009],
         }   ,				)
     __a								=       zero_shot_classifier(
         'The dominant sequence transduction models are based on complex recurrent or convolutional neural networks'
         ' in an encoder-decoder configuration. The best performing models also connect the encoder and decoder'
         ' through an attention mechanism. We propose a new simple network architecture, the Transformer, based'
         ' solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two'
         ' machine translation tasks show these models to be superior in quality while being more parallelizable'
         ' and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014'
         ' English-to-German translation task, improving over the existing best results, including ensembles by'
         ' over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new'
         ' single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small'
         ' fraction of the training costs of the best models from the literature. We show that the Transformer'
         ' generalizes well to other tasks by applying it successfully to English constituency parsing both with'
         ' large and limited training data.'   ,				candidate_labels=['machine learning', 'statistics', 'translation', 'vision']   ,				multi_label=UpperCamelCase   ,				)
     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				{
             'sequence': (
                 'The dominant sequence transduction models are based on complex recurrent or convolutional neural'
                 ' networks in an encoder-decoder configuration. The best performing models also connect the'
                 ' encoder and decoder through an attention mechanism. We propose a new simple network'
                 ' architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence'
                 ' and convolutions entirely. Experiments on two machine translation tasks show these models to be'
                 ' superior in quality while being more parallelizable and requiring significantly less time to'
                 ' train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,'
                 ' improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014'
                 ' English-to-French translation task, our model establishes a new single-model state-of-the-art'
                 ' BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training'
                 ' costs of the best models from the literature. We show that the Transformer generalizes well to'
                 ' other tasks by applying it successfully to English constituency parsing both with large and'
                 ' limited training data.'
             ),
             'labels': ['translation', 'machine learning', 'vision', 'statistics'],
             'scores': [0.817, 0.713, 0.018, 0.018],
         }   ,				)







   @slow
   @require_tf
   def 		UpperCamelCase__      (						self   )					->     Union[str, Any]:
     __a								=       pipeline('zero-shot-classification'   ,				model='roberta-large-mnli'   ,				framework='tf'   )
     __a								=       zero_shot_classifier(
         'Who are you voting for in 2020?'   ,				candidate_labels=['politics', 'public health', 'science']   )

     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				{
             'sequence': 'Who are you voting for in 2020?',
             'labels': ['politics', 'public health', 'science'],
             'scores': [0.976, 0.015, 0.009],
         }   ,				)
     __a								=       zero_shot_classifier(
         'The dominant sequence transduction models are based on complex recurrent or convolutional neural networks'
         ' in an encoder-decoder configuration. The best performing models also connect the encoder and decoder'
         ' through an attention mechanism. We propose a new simple network architecture, the Transformer, based'
         ' solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two'
         ' machine translation tasks show these models to be superior in quality while being more parallelizable'
         ' and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014'
         ' English-to-German translation task, improving over the existing best results, including ensembles by'
         ' over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new'
         ' single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small'
         ' fraction of the training costs of the best models from the literature. We show that the Transformer'
         ' generalizes well to other tasks by applying it successfully to English constituency parsing both with'
         ' large and limited training data.'   ,				candidate_labels=['machine learning', 'statistics', 'translation', 'vision']   ,				multi_label=UpperCamelCase   ,				)
     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				{
             'sequence': (
                 'The dominant sequence transduction models are based on complex recurrent or convolutional neural'
                 ' networks in an encoder-decoder configuration. The best performing models also connect the'
                 ' encoder and decoder through an attention mechanism. We propose a new simple network'
                 ' architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence'
                 ' and convolutions entirely. Experiments on two machine translation tasks show these models to be'
                 ' superior in quality while being more parallelizable and requiring significantly less time to'
                 ' train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,'
                 ' improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014'
                 ' English-to-French translation task, our model establishes a new single-model state-of-the-art'
                 ' BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training'
                 ' costs of the best models from the literature. We show that the Transformer generalizes well to'
                 ' other tasks by applying it successfully to English constituency parsing both with large and'
                 ' limited training data.'
             ),
             'labels': ['translation', 'machine learning', 'vision', 'statistics'],
             'scores': [0.817, 0.713, 0.018, 0.018],
         }   ,				)



