





"""simple docstring"""




from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


lowerCamelCase_	:		str         =   logging.get_logger(__name__)

# General docstring
lowerCamelCase_	:		str         =   'ResNetConfig'

# Base docstring
lowerCamelCase_	:		Optional[Any]         =   'microsoft/resnet-50'
lowerCamelCase_	:		Dict         =   [1, 20_48, 7, 7]

# Image classification docstring
lowerCamelCase_	:		List[str]         =   'microsoft/resnet-50'
lowerCamelCase_	:		Union[str, Any]         =   'tiger cat'

lowerCamelCase_	:		int         =   [
    'microsoft/resnet-50',
    # See all resnet models at https://huggingface.co/models?filter=resnet
]

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



      '''simple docstring'''

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

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Tuple									=    kernel_size // 2
        A_    :			List[Any]									=    tf.keras.layers.ConvaD(
            snake_case_   , kernel_size=snake_case_   , strides=snake_case_   , padding='valid'   , use_bias=snake_case_   , name='convolution'    )
        # Use same default momentum and epsilon as PyTorch equivalent
        A_    :			List[Any]									=    tf.keras.layers.BatchNormalization(epsilon=1E-5   , momentum=0.9   , name='normalization'    )
        A_    :			Any									=    ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('linear'    )

      def    lowerCamelCase_     (	self   , snake_case_    ):

        """simple docstring"""

        A_    :			Optional[Any]									=    (self.pad_value, self.pad_value)
        A_    :			int									=    tf.pad(snake_case_   , [(0, 0), height_pad, width_pad, (0, 0)]    )
        A_    :			List[Any]									=    self.conv(snake_case_    )
        return hidden_state

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			List[str]									=    self.convolution(snake_case_    )
        A_    :			Optional[Any]									=    self.normalization(snake_case_   , training=snake_case_    )
        A_    :			Dict									=    self.activation(snake_case_    )
        return hidden_state


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



      '''simple docstring'''

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

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Optional[int]									=    TFResNetConvLayer(
            config.embedding_size   , kernel_size=7   , stride=2   , activation=config.hidden_act   , name='embedder'   , )
        A_    :			Optional[int]									=    tf.keras.layers.MaxPoolaD(pool_size=3   , strides=2   , padding='valid'   , name='pooler'    )
        A_    :			Tuple									=    config.num_channels

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_		,			A_		,			A_		,			A_    :			Dict									=    shape_list(snake_case_    )
        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.'    )
        A_    :			str									=    pixel_values
        A_    :			Union[str, Any]									=    self.embedder(snake_case_    )
        A_    :			int									=    tf.pad(snake_case_   , [[0, 0], [1, 1], [1, 1], [0, 0]]    )
        A_    :			str									=    self.pooler(snake_case_    )
        return hidden_state


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



      '''simple docstring'''

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

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Optional[Any]									=    tf.keras.layers.ConvaD(
            snake_case_   , kernel_size=1   , strides=snake_case_   , use_bias=snake_case_   , name='convolution'    )
        # Use same default momentum and epsilon as PyTorch equivalent
        A_    :			Optional[Any]									=    tf.keras.layers.BatchNormalization(epsilon=1E-5   , momentum=0.9   , name='normalization'    )

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			List[Any]									=    x
        A_    :			Any									=    self.convolution(snake_case_    )
        A_    :			Dict									=    self.normalization(snake_case_   , training=snake_case_    )
        return hidden_state


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



      '''simple docstring'''

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

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Optional[Any]									=    in_channels != out_channels or stride != 1
        A_    :			Union[str, Any]									=    TFResNetConvLayer(snake_case_   , stride=snake_case_   , name='layer.0'    )
        A_    :			List[str]									=    TFResNetConvLayer(snake_case_   , activation=snake_case_   , name='layer.1'    )
        A_    :			int									=    (
            TFResNetShortCut(snake_case_   , stride=snake_case_   , name='shortcut'    )
            if should_apply_shortcut
            else tf.keras.layers.Activation('linear'   , name='shortcut'    )
        )
        A_    :			Tuple									=    ACTaFN[activation]

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			Optional[int]									=    hidden_state
        A_    :			str									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			List[str]									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			List[Any]									=    self.shortcut(snake_case_   , training=snake_case_    )
        hidden_state += residual
        A_    :			str									=    self.activation(snake_case_    )
        return hidden_state


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



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_   , snake_case_ = 1   , snake_case_ = "relu"   , snake_case_ = 4   , **snake_case_   , ):

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Optional[int]									=    in_channels != out_channels or stride != 1
        A_    :			Optional[int]									=    out_channels // reduction
        A_    :			Optional[Any]									=    TFResNetConvLayer(snake_case_   , kernel_size=1   , name='layer.0'    )
        A_    :			Union[str, Any]									=    TFResNetConvLayer(snake_case_   , stride=snake_case_   , name='layer.1'    )
        A_    :			Union[str, Any]									=    TFResNetConvLayer(snake_case_   , kernel_size=1   , activation=snake_case_   , name='layer.2'    )
        A_    :			Any									=    (
            TFResNetShortCut(snake_case_   , stride=snake_case_   , name='shortcut'    )
            if should_apply_shortcut
            else tf.keras.layers.Activation('linear'   , name='shortcut'    )
        )
        A_    :			Dict									=    ACTaFN[activation]

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        A_    :			List[str]									=    hidden_state
        A_    :			int									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			Dict									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			Optional[int]									=    self.conva(snake_case_   , training=snake_case_    )
        A_    :			str									=    self.shortcut(snake_case_   , training=snake_case_    )
        hidden_state += residual
        A_    :			Union[str, Any]									=    self.activation(snake_case_    )
        return hidden_state


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



      '''simple docstring'''

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

        """simple docstring"""

        super().__init__(**snake_case_    )

        A_    :			str									=    TFResNetBottleNeckLayer if config.layer_type == 'bottleneck' else TFResNetBasicLayer

        A_    :			List[Any]									=    [layer(snake_case_   , snake_case_   , stride=snake_case_   , activation=config.hidden_act   , name='layers.0'    )]
        layers += [
            layer(snake_case_   , snake_case_   , activation=config.hidden_act   , name=F"""layers.{i + 1}"""    )
            for i in range(depth - 1    )
        ]
        A_    :			str									=    layers

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False    ):

        """simple docstring"""

        for layer in self.stage_layers:
          A_    :			List[Any]									=    layer(snake_case_   , training=snake_case_    )
        return hidden_state


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



      '''simple docstring'''

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

        """simple docstring"""

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

      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = False   , snake_case_ = True   , snake_case_ = False   , ):

        """simple docstring"""

        A_    :			Any									=    () if output_hidden_states else None

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

          A_    :			Any									=    stage_module(snake_case_   , training=snake_case_    )

        if output_hidden_states:
          A_    :			List[str]									=    hidden_states + (hidden_state,)

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

        return TFBaseModelOutputWithNoAttention(last_hidden_state=snake_case_   , hidden_states=snake_case_    )


class 					_UpperCAmelCase    (  UpperCAmelCase__						):



      '''simple docstring'''
      lowercase_ :					Dict             =  ResNetConfig
      lowercase_ :					Dict             =  """resnet"""
      lowercase_ :					Union[str, Any]             =  """pixel_values"""

      @property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_2_4, 2_2_4)   , dtype=tf.floataa    )}


lowerCamelCase_	:		Tuple         =   r'\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\n    Parameters:\n        config ([`ResNetConfig`]): 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'


lowerCamelCase_	:		Tuple         =   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            [`ConvNextImageProcessor.__call__`] for details.\n\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'

@keras_serializable
class 					_UpperCAmelCase    (  tf.keras.layers.Layer						):



      '''simple docstring'''
      lowercase_ :					Dict             =  ResNetConfig

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

        """simple docstring"""

        super().__init__(**snake_case_    )
        A_    :			Union[str, Any]									=    config
        A_    :			Optional[Any]									=    TFResNetEmbeddings(snake_case_   , name='embedder'    )
        A_    :			Any									=    TFResNetEncoder(snake_case_   , name='encoder'    )
        A_    :			List[str]									=    tf.keras.layers.GlobalAveragePoolingaD(keepdims=snake_case_    )

      @unpack_inputs
      def    lowerCamelCase_     (	self   , snake_case_   , snake_case_ = None   , snake_case_ = None   , snake_case_ = False   , ):

        """simple docstring"""

        A_    :			Optional[int]									=    (
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        A_    :			Dict									=    return_dict if return_dict is not None else self.config.use_return_dict

        # TF 2.0 image layers can't use NCHW format when running on CPU.
        # We transpose to NHWC format and then transpose back after the full forward pass.
        # (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
        A_    :			str									=    tf.transpose(snake_case_   , perm=[0, 2, 3, 1]    )
        A_    :			Tuple									=    self.embedder(snake_case_   , training=snake_case_    )

        A_    :			List[Any]									=    self.encoder(
            snake_case_   , output_hidden_states=snake_case_   , return_dict=snake_case_   , training=snake_case_    )

        A_    :			Optional[int]									=    encoder_outputs[0]

        A_    :			int									=    self.pooler(snake_case_    )

        # Transpose all the outputs to the NCHW format
        # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
        A_    :			Dict									=    tf.transpose(snake_case_   , (0, 3, 1, 2)    )
        A_    :			int									=    tf.transpose(snake_case_   , (0, 3, 1, 2)    )
        A_    :			Optional[Any]									=    ()
        for hidden_state in encoder_outputs[1:]:
          A_    :			Union[str, Any]									=    hidden_states + tuple(tf.transpose(snake_case_   , (0, 3, 1, 2)    ) for h in hidden_state    )

        if not return_dict:
          return (last_hidden_state, pooled_output) + hidden_states

        A_    :			Dict									=    hidden_states if output_hidden_states else None

        return TFBaseModelOutputWithPoolingAndNoAttention(
            last_hidden_state=snake_case_   , pooler_output=snake_case_   , hidden_states=snake_case_   , )


@add_start_docstrings(
    """The bare ResNet model outputting raw features without any specific head on top."""     ,  UpperCAmelCase__     ,  )
class 					_UpperCAmelCase    (  UpperCAmelCase__						):



      '''simple docstring'''

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

        """simple docstring"""

        super().__init__(snake_case_   , **snake_case_    )
        A_    :			Dict									=    TFResNetMainLayer(config=snake_case_   , name='resnet'    )

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

        """simple docstring"""

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

        A_    :			Tuple									=    self.resnet(
            pixel_values=snake_case_   , output_hidden_states=snake_case_   , return_dict=snake_case_   , training=snake_case_   , )
        return resnet_outputs


@add_start_docstrings(
    """
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """     ,  UpperCAmelCase__     ,  )
class 					_UpperCAmelCase    (  UpperCAmelCase__     ,  UpperCAmelCase__						):



      '''simple docstring'''

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

        """simple docstring"""

        super().__init__(snake_case_   , **snake_case_    )
        A_    :			Any									=    config.num_labels
        A_    :			Tuple									=    TFResNetMainLayer(snake_case_   , name='resnet'    )
        # classification head
        A_    :			List[str]									=    (
            tf.keras.layers.Dense(config.num_labels   , name='classifier.1'    )
            if config.num_labels > 0
            else tf.keras.layers.Activation('linear'   , name='classifier.1'    )
        )

      def    lowerCamelCase_     (	self   , snake_case_    ):

        """simple docstring"""

        A_    :			Tuple									=    tf.keras.layers.Flatten()(snake_case_    )
        A_    :			List[str]									=    self.classifier_layer(snake_case_    )
        return logits

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

        """simple docstring"""

        A_    :			Optional[int]									=    return_dict if return_dict is not None else self.config.use_return_dict

        A_    :			Tuple									=    self.resnet(
            snake_case_   , output_hidden_states=snake_case_   , return_dict=snake_case_   , training=snake_case_    )

        A_    :			Tuple									=    outputs.pooler_output if return_dict else outputs[1]

        A_    :			str									=    self.classifier(snake_case_    )

        A_    :			Tuple									=    None if labels is None else self.hf_compute_loss(snake_case_   , snake_case_    )

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

        return TFImageClassifierOutputWithNoAttention(loss=snake_case_   , logits=snake_case_   , hidden_states=outputs.hidden_states    )
"""simple docstring"""

from copy import deepcopy
from unittest.case import TestCase

import pytest

from datasets.arrow_dataset import Dataset
from datasets.features import Audio, ClassLabel, Features, Image, Sequence, Value
from datasets.info import DatasetInfo
from datasets.tasks import (
    AudioClassification,
    AutomaticSpeechRecognition,
    ImageClassification,
    LanguageModeling,
    QuestionAnsweringExtractive,
    Summarization,
    TextClassification,
    task_template_from_dict,
)
from datasets.utils.py_utils import asdict


__lowercase    =				{
    '''id''': '''5733be284776f41900661182''',
    '''title''': '''University_of_Notre_Dame''',
    '''context''': '''Architecturally, the school has a Catholic character. Atop the Main Building\'s gold dome is a golden statue of the Virgin Mary. Immediately in front of the Main Building and facing it, is a copper statue of Christ with arms upraised with the legend "Venite Ad Me Omnes". Next to the Main Building is the Basilica of the Sacred Heart. Immediately behind the basilica is the Grotto, a Marian place of prayer and reflection. It is a replica of the grotto at Lourdes, France where the Virgin Mary reputedly appeared to Saint Bernadette Soubirous in 1858. At the end of the main drive (and in a direct line that connects through 3 statues and the Gold Dome), is a simple, modern stone statue of Mary.''',
    '''question''': '''To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France?''',
    '''answers''': {'''text''': ['''Saint Bernadette Soubirous'''], '''answer_start''': [515]},
}


@pytest.mark.parametrize(
    '''task_cls'''							,					[
        AudioClassification,
        AutomaticSpeechRecognition,
        ImageClassification,
        LanguageModeling,
        QuestionAnsweringExtractive,
        Summarization,
        TextClassification,
    ]							,					)
def    lowerCAmelCase			(__UpperCamelCase							:    List[str]			):
							"""simple docstring"""


							__UpperCamelCase							=task_cls()
							__UpperCamelCase							=asdict(__UpperCamelCase			)
							__UpperCamelCase							=task_template_from_dict(__UpperCamelCase			)
							assert task == reloaded






class 		_lowercase :



						"""simple docstring"""




						def   UpperCAmelCase_ (				self							:    Union[str, Any]				)				->				List[Any]:
													'''simple docstring'''



													__UpperCamelCase							=LanguageModeling(text_column='''input_text'''				)
													assert {"input_text": "text"} == task.column_mapping





						def   UpperCAmelCase_ (				self							:    str				)				->				int:
													'''simple docstring'''



													__UpperCamelCase							=Features({'''text''': Value('''string'''				)}				)
													__UpperCamelCase							={'''text_column''': '''input_text'''}
													__UpperCamelCase							=LanguageModeling.from_dict(UpperCamelCase__				)
													assert "language-modeling" == task.task
													assert input_schema == task.input_schema






class 		_lowercase (						__a      ):



						"""simple docstring"""




						def   UpperCAmelCase_ (				self							:    Optional[Any]				)				->				Dict:
													'''simple docstring'''



													__UpperCamelCase							=sorted(['''pos''', '''neg''']				)





						def   UpperCAmelCase_ (				self							:    Tuple				)				->				Tuple:
													'''simple docstring'''



													__UpperCamelCase							=TextClassification(text_column='''input_text'''     , label_column='''input_label'''				)
													self.assertDictEqual({'''input_text''': '''text''', '''input_label''': '''labels'''}     , task.column_mapping				)





						def   UpperCAmelCase_ (				self							:    Union[str, Any]				)				->				Union[str, Any]:
													'''simple docstring'''



													__UpperCamelCase							=Features({'''text''': Value('''string'''				)}				)
													# Labels are cast to tuple during `TextClassification.__post_init__`, so we do the same here
													__UpperCamelCase							=Features({'''labels''': ClassLabel}				)
													__UpperCamelCase							={'''text_column''': '''input_text''', '''label_column''': '''input_labels'''}
													__UpperCamelCase							=TextClassification.from_dict(UpperCamelCase__				)
													self.assertEqual('''text-classification'''     , task.task				)
													self.assertEqual(UpperCamelCase__     , task.input_schema				)
													self.assertEqual(UpperCamelCase__     , task.label_schema				)





						def   UpperCAmelCase_ (				self							:    Tuple				)				->				Optional[Any]:
													'''simple docstring'''



													__UpperCamelCase							=TextClassification(text_column='''input_text'''     , label_column='''input_label'''				)
													self.assertEqual(task.label_schema['''labels''']     , UpperCamelCase__				)
													__UpperCamelCase							=task.align_with_features(Features({'''input_label''': ClassLabel(names=self.labels				)}				)				)
													self.assertEqual(task.label_schema['''labels''']     , ClassLabel(names=self.labels				)				)






class 		_lowercase (						__a      ):



						"""simple docstring"""




						def   UpperCAmelCase_ (				self							:    Dict				)				->				List[Any]:
													'''simple docstring'''



													__UpperCamelCase							=QuestionAnsweringExtractive(
													    context_column='''input_context'''     , question_column='''input_question'''     , answers_column='''input_answers'''				)
													self.assertDictEqual(
													    {'''input_context''': '''context''', '''input_question''': '''question''', '''input_answers''': '''answers'''}     , task.column_mapping				)





						def   UpperCAmelCase_ (				self							:    Optional[Any]				)				->				Optional[Any]:
													'''simple docstring'''



													__UpperCamelCase							=Features({'''question''': Value('''string'''				), '''context''': Value('''string'''				)}				)
													__UpperCamelCase							=Features(
													    {
													        '''answers''': Sequence(
													            {
													                '''text''': Value('''string'''				),
													                '''answer_start''': Value('''int32'''				),
													            }				)
													    }				)
													__UpperCamelCase							={
													    '''context_column''': '''input_input_context''',
													    '''question_column''': '''input_question''',
													    '''answers_column''': '''input_answers''',
													}
													__UpperCamelCase							=QuestionAnsweringExtractive.from_dict(UpperCamelCase__				)
													self.assertEqual('''question-answering-extractive'''     , task.task				)
													self.assertEqual(UpperCamelCase__     , task.input_schema				)
													self.assertEqual(UpperCamelCase__     , task.label_schema				)






class 		_lowercase (						__a      ):



						"""simple docstring"""




						def   UpperCAmelCase_ (				self							:    List[Any]				)				->				str:
													'''simple docstring'''



													__UpperCamelCase							=Summarization(text_column='''input_text'''     , summary_column='''input_summary'''				)
													self.assertDictEqual({'''input_text''': '''text''', '''input_summary''': '''summary'''}     , task.column_mapping				)





						def   UpperCAmelCase_ (				self							:    int				)				->				List[Any]:
													'''simple docstring'''



													__UpperCamelCase							=Features({'''text''': Value('''string'''				)}				)
													__UpperCamelCase							=Features({'''summary''': Value('''string'''				)}				)
													__UpperCamelCase							={'''text_column''': '''input_text''', '''summary_column''': '''input_summary'''}
													__UpperCamelCase							=Summarization.from_dict(UpperCamelCase__				)
													self.assertEqual('''summarization'''     , task.task				)
													self.assertEqual(UpperCamelCase__     , task.input_schema				)
													self.assertEqual(UpperCamelCase__     , task.label_schema				)






class 		_lowercase (						__a      ):



						"""simple docstring"""




						def   UpperCAmelCase_ (				self							:    List[Any]				)				->				Dict:
													'''simple docstring'''



													__UpperCamelCase							=AutomaticSpeechRecognition(audio_column='''input_audio'''     , transcription_column='''input_transcription'''				)
													self.assertDictEqual({'''input_audio''': '''audio''', '''input_transcription''': '''transcription'''}     , task.column_mapping				)





						def   UpperCAmelCase_ (				self							:    Union[str, Any]				)				->				List[str]:
													'''simple docstring'''



													__UpperCamelCase							=Features({'''audio''': Audio()}				)
													__UpperCamelCase							=Features({'''transcription''': Value('''string'''				)}				)
													__UpperCamelCase							={
													    '''audio_column''': '''input_audio''',
													    '''transcription_column''': '''input_transcription''',
													}
													__UpperCamelCase							=AutomaticSpeechRecognition.from_dict(UpperCamelCase__				)
													self.assertEqual('''automatic-speech-recognition'''     , task.task				)
													self.assertEqual(UpperCamelCase__     , task.input_schema				)
													self.assertEqual(UpperCamelCase__     , task.label_schema				)






class 		_lowercase (						__a      ):



						"""simple docstring"""




						def   UpperCAmelCase_ (				self							:    List[str]				)				->				List[str]:
													'''simple docstring'''



													__UpperCamelCase							=sorted(['''pos''', '''neg''']				)





						def   UpperCAmelCase_ (				self							:    Union[str, Any]				)				->				int:
													'''simple docstring'''



													__UpperCamelCase							=AudioClassification(audio_column='''input_audio'''     , label_column='''input_label'''				)
													self.assertDictEqual({'''input_audio''': '''audio''', '''input_label''': '''labels'''}     , task.column_mapping				)





						def   UpperCAmelCase_ (				self							:    Dict				)				->				Any:
													'''simple docstring'''



													__UpperCamelCase							=Features({'''audio''': Audio()}				)
													__UpperCamelCase							=Features({'''labels''': ClassLabel}				)
													__UpperCamelCase							={
													    '''audio_column''': '''input_image''',
													    '''label_column''': '''input_label''',
													}
													__UpperCamelCase							=AudioClassification.from_dict(UpperCamelCase__				)
													self.assertEqual('''audio-classification'''     , task.task				)
													self.assertEqual(UpperCamelCase__     , task.input_schema				)
													self.assertEqual(UpperCamelCase__     , task.label_schema				)





						def   UpperCAmelCase_ (				self							:    Tuple				)				->				List[str]:
													'''simple docstring'''



													__UpperCamelCase							=AudioClassification(audio_column='''input_audio'''     , label_column='''input_label'''				)
													self.assertEqual(task.label_schema['''labels''']     , UpperCamelCase__				)
													__UpperCamelCase							=task.align_with_features(Features({'''input_label''': ClassLabel(names=self.labels				)}				)				)
													self.assertEqual(task.label_schema['''labels''']     , ClassLabel(names=self.labels				)				)






class 		_lowercase (						__a      ):



						"""simple docstring"""




						def   UpperCAmelCase_ (				self							:    Optional[Any]				)				->				str:
													'''simple docstring'''



													__UpperCamelCase							=sorted(['''pos''', '''neg''']				)





						def   UpperCAmelCase_ (				self							:    str				)				->				Tuple:
													'''simple docstring'''



													__UpperCamelCase							=ImageClassification(image_column='''input_image'''     , label_column='''input_label'''				)
													self.assertDictEqual({'''input_image''': '''image''', '''input_label''': '''labels'''}     , task.column_mapping				)





						def   UpperCAmelCase_ (				self							:    Optional[Any]				)				->				List[str]:
													'''simple docstring'''



													__UpperCamelCase							=Features({'''image''': Image()}				)
													__UpperCamelCase							=Features({'''labels''': ClassLabel}				)
													__UpperCamelCase							={
													    '''image_column''': '''input_image''',
													    '''label_column''': '''input_label''',
													}
													__UpperCamelCase							=ImageClassification.from_dict(UpperCamelCase__				)
													self.assertEqual('''image-classification'''     , task.task				)
													self.assertEqual(UpperCamelCase__     , task.input_schema				)
													self.assertEqual(UpperCamelCase__     , task.label_schema				)





						def   UpperCAmelCase_ (				self							:    str				)				->				Optional[int]:
													'''simple docstring'''



													__UpperCamelCase							=ImageClassification(image_column='''input_image'''     , label_column='''input_label'''				)
													self.assertEqual(task.label_schema['''labels''']     , UpperCamelCase__				)
													__UpperCamelCase							=task.align_with_features(Features({'''input_label''': ClassLabel(names=self.labels				)}				)				)
													self.assertEqual(task.label_schema['''labels''']     , ClassLabel(names=self.labels				)				)






class 		_lowercase (						__a      ):



						"""simple docstring"""




						def   UpperCAmelCase_ (				self							:    Optional[Any]				)				->				List[Any]:
													'''simple docstring'''



													__UpperCamelCase							=DatasetInfo(task_templates=QuestionAnsweringExtractive()				)
													__UpperCamelCase							=Dataset.from_dict({k: [v] for k, v in SAMPLE_QUESTION_ANSWERING_EXTRACTIVE.items()}     , info=UpperCamelCase__				)
													assert isinstance(dataset.info.task_templates     , UpperCamelCase__				)
													assert len(dataset.info.task_templates				) == 1

													def keep_task(UpperCamelCase__							:    Optional[int]				):
																				return x

													def dont_keep_task(UpperCamelCase__							:    Optional[int]				):
																				__UpperCamelCase							=deepcopy(UpperCamelCase__				)
																				__UpperCamelCase							=0
																				return out

													__UpperCamelCase							=dataset.map(UpperCamelCase__				)
													assert mapped_dataset.info.task_templates == dataset.info.task_templates
													# reload from cache
													__UpperCamelCase							=dataset.map(UpperCamelCase__				)
													assert mapped_dataset.info.task_templates == dataset.info.task_templates

													__UpperCamelCase							=dataset.map(UpperCamelCase__				)
													assert mapped_dataset.info.task_templates == []
													# reload from cache
													__UpperCamelCase							=dataset.map(UpperCamelCase__				)
													assert mapped_dataset.info.task_templates == []





						def   UpperCAmelCase_ (				self							:    List[str]				)				->				Dict:
													'''simple docstring'''



													__UpperCamelCase							=Features({'''text''': Value('''string'''				), '''label''': ClassLabel(names=('''pos''', '''neg''')				)}				)
													__UpperCamelCase							=TextClassification(text_column='''text'''     , label_column='''label'''				)
													__UpperCamelCase							=DatasetInfo(features=UpperCamelCase__     , task_templates=UpperCamelCase__				)
													__UpperCamelCase							=Dataset.from_dict({'''text''': ['''A sentence.'''], '''label''': ['''pos''']}     , info=UpperCamelCase__				)

													def process(UpperCamelCase__							:    Any				):
																				return example

													__UpperCamelCase							=dataset.remove_columns('''label'''				)
													__UpperCamelCase							=modified_dataset.map(UpperCamelCase__				)
													assert mapped_dataset.info.task_templates == []



