




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


A			   =logging.get_logger(__name__)

# General docstring
A			   ="ResNetConfig"

# Base docstring
A			   ="microsoft/resnet-50"
A			   =[1, 20_48, 7, 7]

# Image classification docstring
A			   ="microsoft/resnet-50"
A			   ="tiger cat"

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


class       _a  (     tf.keras.layers.Layer			):
       def __init__(     self						:     Dict       ,    lowercase						:     int       ,    lowercase						:     int = 3       ,    lowercase						:     int = 1       ,    lowercase						:     str = "relu"       ,    **lowercase						:     Dict    ):



           '''simple docstring'''

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



           '''simple docstring'''

           UpperCAmelCase      	=		UpperCAmelCase      	=		(self.pad_value, self.pad_value)
           UpperCAmelCase      	=		tf.pad(UpperCamelCase_       ,    [(0, 0), height_pad, width_pad, (0, 0)]    )
           UpperCAmelCase      	=		self.conv(UpperCamelCase_    )
           return hidden_state







       def    A				(     self						:     Optional[int]       ,    lowercase						:     tf.Tensor       ,    lowercase						:     bool = False    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.convolution(UpperCamelCase_    )
           UpperCAmelCase      	=		self.normalization(UpperCamelCase_       ,    training=UpperCamelCase_    )
           UpperCAmelCase      	=		self.activation(UpperCamelCase_    )
           return hidden_state






class       _a  (     tf.keras.layers.Layer			):
       def __init__(     self						:     int       ,    lowercase						:     ResNetConfig       ,    **lowercase						:     Tuple    ):



           '''simple docstring'''

           super().__init__(**UpperCamelCase_    )
           UpperCAmelCase      	=		TFResNetConvLayer(
               config.embedding_size       ,    kernel_size=7       ,    stride=2       ,    activation=config.hidden_act       ,    name='''embedder'''       ,    )
           UpperCAmelCase      	=		tf.keras.layers.MaxPoolaD(pool_size=3       ,    strides=2       ,    padding='''valid'''       ,    name='''pooler'''    )
           UpperCAmelCase      	=		config.num_channels







       def    A				(     self						:     Any       ,    lowercase						:     tf.Tensor       ,    lowercase						:     bool = False    ):



           '''simple docstring'''

           UpperCAmelCase	,					UpperCAmelCase	,					UpperCAmelCase	,					UpperCAmelCase      	=		shape_list(UpperCamelCase_    )
           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.'''    )
           UpperCAmelCase      	=		pixel_values
           UpperCAmelCase      	=		self.embedder(UpperCamelCase_    )
           UpperCAmelCase      	=		tf.pad(UpperCamelCase_       ,    [[0, 0], [1, 1], [1, 1], [0, 0]]    )
           UpperCAmelCase      	=		self.pooler(UpperCamelCase_    )
           return hidden_state






class       _a  (     tf.keras.layers.Layer			):
       def __init__(     self						:     str       ,    lowercase						:     int       ,    lowercase						:     int = 2       ,    **lowercase						:     Optional[Any]    ):



           '''simple docstring'''

           super().__init__(**UpperCamelCase_    )
           UpperCAmelCase      	=		tf.keras.layers.ConvaD(
               UpperCamelCase_       ,    kernel_size=1       ,    strides=UpperCamelCase_       ,    use_bias=UpperCamelCase_       ,    name='''convolution'''    )
           # Use same default momentum and epsilon as PyTorch equivalent
           UpperCAmelCase      	=		tf.keras.layers.BatchNormalization(epsilon=1E-5       ,    momentum=0.9       ,    name='''normalization'''    )







       def    A				(     self						:     str       ,    lowercase						:     tf.Tensor       ,    lowercase						:     bool = False    ):



           '''simple docstring'''

           UpperCAmelCase      	=		x
           UpperCAmelCase      	=		self.convolution(UpperCamelCase_    )
           UpperCAmelCase      	=		self.normalization(UpperCamelCase_       ,    training=UpperCamelCase_    )
           return hidden_state






class       _a  (     tf.keras.layers.Layer			):
       def __init__(     self						:     List[str]       ,    lowercase						:     int       ,    lowercase						:     int       ,    lowercase						:     int = 1       ,    lowercase						:     str = "relu"       ,    **lowercase						:     Any    ):



           '''simple docstring'''

           super().__init__(**UpperCamelCase_    )
           UpperCAmelCase      	=		in_channels != out_channels or stride != 1
           UpperCAmelCase      	=		TFResNetConvLayer(UpperCamelCase_       ,    stride=UpperCamelCase_       ,    name='''layer.0'''    )
           UpperCAmelCase      	=		TFResNetConvLayer(UpperCamelCase_       ,    activation=UpperCamelCase_       ,    name='''layer.1'''    )
           UpperCAmelCase      	=		(
               TFResNetShortCut(UpperCamelCase_       ,    stride=UpperCamelCase_       ,    name='''shortcut'''    )
               if should_apply_shortcut
               else tf.keras.layers.Activation('''linear'''       ,    name='''shortcut'''    )
           )
           UpperCAmelCase      	=		ACTaFN[activation]







       def    A				(     self						:     Union[str, Any]       ,    lowercase						:     tf.Tensor       ,    lowercase						:     bool = False    ):



           '''simple docstring'''

           UpperCAmelCase      	=		hidden_state
           UpperCAmelCase      	=		self.conva(UpperCamelCase_       ,    training=UpperCamelCase_    )
           UpperCAmelCase      	=		self.conva(UpperCamelCase_       ,    training=UpperCamelCase_    )
           UpperCAmelCase      	=		self.shortcut(UpperCamelCase_       ,    training=UpperCamelCase_    )
           hidden_state += residual
           UpperCAmelCase      	=		self.activation(UpperCamelCase_    )
           return hidden_state






class       _a  (     tf.keras.layers.Layer			):
       def __init__(     self						:     Optional[Any]       ,    lowercase						:     int       ,    lowercase						:     int       ,    lowercase						:     int = 1       ,    lowercase						:     str = "relu"       ,    lowercase						:     int = 4       ,    **lowercase						:     str       ,    ):



           '''simple docstring'''

           super().__init__(**UpperCamelCase_    )
           UpperCAmelCase      	=		in_channels != out_channels or stride != 1
           UpperCAmelCase      	=		out_channels // reduction
           UpperCAmelCase      	=		TFResNetConvLayer(UpperCamelCase_       ,    kernel_size=1       ,    name='''layer.0'''    )
           UpperCAmelCase      	=		TFResNetConvLayer(UpperCamelCase_       ,    stride=UpperCamelCase_       ,    name='''layer.1'''    )
           UpperCAmelCase      	=		TFResNetConvLayer(UpperCamelCase_       ,    kernel_size=1       ,    activation=UpperCamelCase_       ,    name='''layer.2'''    )
           UpperCAmelCase      	=		(
               TFResNetShortCut(UpperCamelCase_       ,    stride=UpperCamelCase_       ,    name='''shortcut'''    )
               if should_apply_shortcut
               else tf.keras.layers.Activation('''linear'''       ,    name='''shortcut'''    )
           )
           UpperCAmelCase      	=		ACTaFN[activation]







       def    A				(     self						:     Any       ,    lowercase						:     tf.Tensor       ,    lowercase						:     bool = False    ):



           '''simple docstring'''

           UpperCAmelCase      	=		hidden_state
           UpperCAmelCase      	=		self.conva(UpperCamelCase_       ,    training=UpperCamelCase_    )
           UpperCAmelCase      	=		self.conva(UpperCamelCase_       ,    training=UpperCamelCase_    )
           UpperCAmelCase      	=		self.conva(UpperCamelCase_       ,    training=UpperCamelCase_    )
           UpperCAmelCase      	=		self.shortcut(UpperCamelCase_       ,    training=UpperCamelCase_    )
           hidden_state += residual
           UpperCAmelCase      	=		self.activation(UpperCamelCase_    )
           return hidden_state






class       _a  (     tf.keras.layers.Layer			):
       def __init__(     self						:     str       ,    lowercase						:     ResNetConfig       ,    lowercase						:     int       ,    lowercase						:     int       ,    lowercase						:     int = 2       ,    lowercase						:     int = 2       ,    **lowercase						:     Optional[int]    ):



           '''simple docstring'''

           super().__init__(**UpperCamelCase_    )

           UpperCAmelCase      	=		TFResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else TFResNetBasicLayer

           UpperCAmelCase      	=		[layer(UpperCamelCase_       ,    UpperCamelCase_       ,    stride=UpperCamelCase_       ,    activation=config.hidden_act       ,    name='''layers.0'''    )]
           layers += [
               layer(UpperCamelCase_       ,    UpperCamelCase_       ,    activation=config.hidden_act       ,    name=f"layers.{i + 1}"    )
               for i in range(depth - 1    )
           ]
           UpperCAmelCase      	=		layers







       def    A				(     self						:     List[str]       ,    lowercase						:     tf.Tensor       ,    lowercase						:     bool = False    ):



           '''simple docstring'''

           for layer in self.stage_layers:
               UpperCAmelCase      	=		layer(UpperCamelCase_       ,    training=UpperCamelCase_    )
           return hidden_state






class       _a  (     tf.keras.layers.Layer			):
       def __init__(     self						:     int       ,    lowercase						:     ResNetConfig       ,    **lowercase						:     Dict    ):



           '''simple docstring'''

           super().__init__(**UpperCamelCase_    )
           # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
           UpperCAmelCase      	=		[
               TFResNetStage(
                   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'''       ,    )
           ]
           for i, (in_channels, out_channels, depth) in enumerate(
               zip(config.hidden_sizes       ,    config.hidden_sizes[1:]       ,    config.depths[1:]    )    ):
               self.stages.append(TFResNetStage(UpperCamelCase_       ,    UpperCamelCase_       ,    UpperCamelCase_       ,    depth=UpperCamelCase_       ,    name=f"stages.{i + 1}"    )    )







       def    A				(     self						:     Optional[Any]       ,    lowercase						:     tf.Tensor       ,    lowercase						:     bool = False       ,    lowercase						:     bool = True       ,    lowercase						:     bool = False       ,    ):



           '''simple docstring'''

           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_       ,    training=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_    )






class       _a  (     lowercase_			):
       __a    :					Dict           = ResNetConfig
       __a    :					Optional[Any]           = """resnet"""
       __a    :					str           = """pixel_values"""
       @property
       def    A				(     self						:     str    ):



           '''simple docstring'''

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






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


A			   =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       _a  (     tf.keras.layers.Layer			):
       __a    :					Any           = ResNetConfig
       def __init__(     self						:     str       ,    lowercase						:     ResNetConfig       ,    **lowercase						:     str    ):



           '''simple docstring'''

           super().__init__(**UpperCamelCase_    )
           UpperCAmelCase      	=		config
           UpperCAmelCase      	=		TFResNetEmbeddings(UpperCamelCase_       ,    name='''embedder'''    )
           UpperCAmelCase      	=		TFResNetEncoder(UpperCamelCase_       ,    name='''encoder'''    )
           UpperCAmelCase      	=		tf.keras.layers.GlobalAveragePoolingaD(keepdims=UpperCamelCase_    )







       @unpack_inputs
       def    A				(     self						:     str       ,    lowercase						:     tf.Tensor       ,    lowercase						:     Optional[bool] = None       ,    lowercase						:     Optional[bool] = None       ,    lowercase						:     bool = False       ,    ):



           '''simple docstring'''

           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

           # 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)
           UpperCAmelCase      	=		tf.transpose(UpperCamelCase_       ,    perm=[0, 2, 3, 1]    )
           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_    )

           # Transpose all the outputs to the NCHW format
           # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
           UpperCAmelCase      	=		tf.transpose(UpperCamelCase_       ,    (0, 3, 1, 2)    )
           UpperCAmelCase      	=		tf.transpose(UpperCamelCase_       ,    (0, 3, 1, 2)    )
           UpperCAmelCase      	=		()
           for hidden_state in encoder_outputs[1:]:
               UpperCAmelCase      	=		hidden_states + tuple(tf.transpose(UpperCamelCase_       ,    (0, 3, 1, 2)    ) for h in hidden_state    )

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

           UpperCAmelCase      	=		hidden_states if output_hidden_states else None

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






@add_start_docstrings(
    """The bare ResNet model outputting raw features without any specific head on top."""							,							lowercase_							,							)
class       _a  (     lowercase_			):
       def __init__(     self						:     int       ,    lowercase						:     ResNetConfig       ,    **lowercase						:     Dict    ):



           '''simple docstring'''

           super().__init__(UpperCamelCase_       ,    **UpperCamelCase_    )
           UpperCAmelCase      	=		TFResNetMainLayer(config=UpperCamelCase_       ,    name='''resnet'''    )







       @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       ,    )
       @unpack_inputs
       def    A				(     self						:     Dict       ,    lowercase						:     tf.Tensor       ,    lowercase						:     Optional[bool] = None       ,    lowercase						:     Optional[bool] = None       ,    lowercase						:     bool = False       ,    ):



           '''simple docstring'''

           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.resnet(
               pixel_values=UpperCamelCase_       ,    output_hidden_states=UpperCamelCase_       ,    return_dict=UpperCamelCase_       ,    training=UpperCamelCase_       ,    )
           return resnet_outputs






@add_start_docstrings(
    """\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    """							,							lowercase_							,							)
class       _a  (     lowercase_							,							lowercase_			):
       def __init__(     self						:     int       ,    lowercase						:     ResNetConfig       ,    **lowercase						:     Any    ):



           '''simple docstring'''

           super().__init__(UpperCamelCase_       ,    **UpperCamelCase_    )
           UpperCAmelCase      	=		config.num_labels
           UpperCAmelCase      	=		TFResNetMainLayer(UpperCamelCase_       ,    name='''resnet'''    )
           # classification head
           UpperCAmelCase      	=		(
               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    A				(     self						:     Union[str, Any]       ,    lowercase						:     tf.Tensor    ):



           '''simple docstring'''

           UpperCAmelCase      	=		tf.keras.layers.Flatten()(UpperCamelCase_    )
           UpperCAmelCase      	=		self.classifier_layer(UpperCamelCase_    )
           return logits







       @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       ,    )
       @unpack_inputs
       def    A				(     self						:     str       ,    lowercase						:     tf.Tensor = None       ,    lowercase						:     tf.Tensor = None       ,    lowercase						:     bool = None       ,    lowercase						:     bool = None       ,    lowercase						:     bool = False       ,    ):



           '''simple docstring'''

           UpperCAmelCase      	=		return_dict if return_dict is not None else self.config.use_return_dict

           UpperCAmelCase      	=		self.resnet(
               UpperCamelCase_       ,    output_hidden_states=UpperCamelCase_       ,    return_dict=UpperCamelCase_       ,    training=UpperCamelCase_    )

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

           UpperCAmelCase      	=		self.classifier(UpperCamelCase_    )

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

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

           return TFImageClassifierOutputWithNoAttention(loss=UpperCamelCase_       ,    logits=UpperCamelCase_       ,    hidden_states=outputs.hidden_states    )











'''simple docstring'''







import subprocess
from typing import Union

import numpy as np
import requests

from ..utils import add_end_docstrings, is_torch_available, is_torchaudio_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_torch_available():
   from ..models.auto.modeling_auto import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING

A			   =logging.get_logger(__name__)





def 						snake_case_							(_a     :							bytes   ,       _a     :							int					):
    UpperCAmelCase      	=		F"{sampling_rate}"
    UpperCAmelCase      	=		'''1'''
    UpperCAmelCase      	=		'''f32le'''
    UpperCAmelCase      	=		[
        '''ffmpeg''',
        '''-i''',
        '''pipe:0''',
        '''-ac''',
        ac,
        '''-ar''',
        ar,
        '''-f''',
        format_for_conversion,
        '''-hide_banner''',
        '''-loglevel''',
        '''quiet''',
        '''pipe:1''',
    ]

    try:
        UpperCAmelCase      	=		subprocess.Popen(_a   ,       stdin=subprocess.PIPE   ,       stdout=subprocess.PIPE					)
    except FileNotFoundError:
        raise ValueError('''ffmpeg was not found but is required to load audio files from filename'''					)
    UpperCAmelCase      	=		ffmpeg_process.communicate(_a					)
    UpperCAmelCase      	=		output_stream[0]

    UpperCAmelCase      	=		np.frombuffer(_a   ,       np.floataa					)
    if audio.shape[0] == 0:
        raise ValueError('''Malformed soundfile'''					)
    return audio







@add_end_docstrings(__a			)
class       _a  (     __a			):
       def __init__(     self						:     Dict       ,    *lowercase						:     Dict       ,    **lowercase						:     Any    ):



           '''simple docstring'''

           UpperCAmelCase      	=		5
           super().__init__(*lowercase       ,    **lowercase    )

           if self.framework != "pt":
               raise ValueError(f"The {self.__class__} is only available in PyTorch."    )

           self.check_model_type(lowercase    )
       def __call__(     self						:     List[Any]       ,    lowercase						:     Union[np.ndarray, bytes, str]       ,    **lowercase						:     Dict       ,    ):



           '''simple docstring'''

           return super().__call__(lowercase       ,    **lowercase    )
       def    A				(     self						:     Tuple       ,    lowercase						:     Dict=None       ,    **lowercase						:     List[str]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		{}
           if top_k is not None:
               if top_k > self.model.config.num_labels:
                   UpperCAmelCase      	=		self.model.config.num_labels
               UpperCAmelCase      	=		top_k
           return {}, {}, postprocess_params
       def    A				(     self						:     List[Any]       ,    lowercase						:     Union[str, Any]    ):



           '''simple docstring'''

           if isinstance(lowercase       ,    lowercase    ):
               if inputs.startswith('''http://'''    ) or inputs.startswith('''https://'''    ):
                   # We need to actually check for a real protocol, otherwise it's impossible to use a local file
                   # like http_huggingface_co.png
                   UpperCAmelCase      	=		requests.get(lowercase    ).content
               else:
                   with open(lowercase       ,    '''rb'''    ) as f:
                       UpperCAmelCase      	=		f.read()

           if isinstance(lowercase       ,    lowercase    ):
               UpperCAmelCase      	=		ffmpeg_read(lowercase       ,    self.feature_extractor.sampling_rate    )

           if isinstance(lowercase       ,    lowercase    ):
               # Accepting `"array"` which is the key defined in `datasets` for
               # better integration
               if not ("sampling_rate" in inputs and ("raw" in inputs or "array" in inputs)):
                   raise ValueError(
                       '''When passing a dictionary to AudioClassificationPipeline, the dict needs to contain a '''
                       '''"raw" key containing the numpy array representing the audio and a "sampling_rate" key, '''
                       '''containing the sampling_rate associated with that array'''    )

               UpperCAmelCase      	=		inputs.pop('''raw'''       ,    lowercase    )
               if _inputs is None:
                   # Remove path which will not be used from `datasets`.
                   inputs.pop('''path'''       ,    lowercase    )
                   UpperCAmelCase      	=		inputs.pop('''array'''       ,    lowercase    )
               UpperCAmelCase      	=		inputs.pop('''sampling_rate'''    )
               UpperCAmelCase      	=		_inputs
               if in_sampling_rate != self.feature_extractor.sampling_rate:
                   import torch

                   if is_torchaudio_available():
                       from torchaudio import functional as F
                   else:
                       raise ImportError(
                           '''torchaudio is required to resample audio samples in AudioClassificationPipeline. '''
                           '''The torchaudio package can be installed through: `pip install torchaudio`.'''    )

                   UpperCAmelCase      	=		F.resample(
                       torch.from_numpy(lowercase    )       ,    lowercase       ,    self.feature_extractor.sampling_rate    ).numpy()

           if not isinstance(lowercase       ,    np.ndarray    ):
               raise ValueError('''We expect a numpy ndarray as input'''    )
           if len(inputs.shape    ) != 1:
               raise ValueError('''We expect a single channel audio input for AudioClassificationPipeline'''    )

           UpperCAmelCase      	=		self.feature_extractor(
               lowercase       ,    sampling_rate=self.feature_extractor.sampling_rate       ,    return_tensors='''pt'''    )
           return processed
       def    A				(     self						:     Optional[Any]       ,    lowercase						:     List[str]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.model(**lowercase    )
           return model_outputs







       def    A				(     self						:     Union[str, Any]       ,    lowercase						:     Optional[Any]       ,    lowercase						:     List[str]=5    ):



           '''simple docstring'''

           UpperCAmelCase      	=		model_outputs.logits[0].softmax(-1    )
           UpperCAmelCase	,					UpperCAmelCase      	=		probs.topk(lowercase    )

           UpperCAmelCase      	=		scores.tolist()
           UpperCAmelCase      	=		ids.tolist()

           UpperCAmelCase      	=		[{'''score''': score, '''label''': self.model.config.idalabel[_id]} for score, _id in zip(lowercase       ,    lowercase    )]

           return labels




