





'''simple docstring'''



from collections import UserDict
from typing import Union

import numpy as np
import requests

from ..utils import (
    add_end_docstrings,
    logging,
)
from .audio_classification import ffmpeg_read
from .base import PIPELINE_INIT_ARGS, Pipeline


_SCREAMING_SNAKE_CASE					=    logging.get_logger(__name__)






@add_end_docstrings(lowerCAmelCase__						)
class 							__lowercase       (      lowerCAmelCase__						):







 '''simple docstring'''

 def __init__(self     ,**_lowerCamelCase )							->							Optional[int]:







    '''simple docstring'''





    super().__init__(**_lowerCamelCase )

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


 def __call__(self     ,_lowerCamelCase     ,**_lowerCamelCase )							->							Union[str, Any]:







    '''simple docstring'''





    return super().__call__(_lowerCamelCase     ,**_lowerCamelCase )


 def 						_UpperCAmelCase     (self     ,**_lowerCamelCase )							->							List[str]:







    '''simple docstring'''





    __lowercase										=							{}
    if "candidate_labels" in kwargs:
       __lowercase										=							kwargs['''candidate_labels''']
    if "hypothesis_template" in kwargs:
       __lowercase										=							kwargs['''hypothesis_template''']

    return preprocess_params, {}, {}


 def 						_UpperCAmelCase     (self     ,_lowerCamelCase     ,_lowerCamelCase=None     ,_lowerCamelCase="This is a sound of {}." )							->							Any:







    '''simple docstring'''





    if isinstance(_lowerCamelCase     ,_lowerCamelCase ):
       if audio.startswith('''http://''' ) or audio.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
          __lowercase										=							requests.get(_lowerCamelCase ).content
       else:
          with open(_lowerCamelCase     ,'''rb''' ) as f:
             __lowercase										=							f.read()

    if isinstance(_lowerCamelCase     ,_lowerCamelCase ):
       __lowercase										=							ffmpeg_read(_lowerCamelCase     ,self.feature_extractor.sampling_rate )

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

    __lowercase										=							self.feature_extractor(
        [audio]     ,sampling_rate=self.feature_extractor.sampling_rate     ,return_tensors='''pt''' )
    __lowercase										=							candidate_labels
    __lowercase										=							[hypothesis_template.format(_lowerCamelCase ) for x in candidate_labels]
    __lowercase										=							self.tokenizer(_lowerCamelCase     ,return_tensors=self.framework     ,padding=_lowerCamelCase )
    __lowercase										=							[text_inputs]
    return inputs


 def 						_UpperCAmelCase     (self     ,_lowerCamelCase )							->							List[str]:







    '''simple docstring'''





    __lowercase										=							model_inputs.pop('''candidate_labels''' )
    __lowercase										=							model_inputs.pop('''text_inputs''' )
    if isinstance(text_inputs[0]     ,_lowerCamelCase ):
       __lowercase										=							text_inputs[0]
    else:
       # Batching case.
       __lowercase										=							text_inputs[0][0]

    __lowercase										=							self.model(**_lowerCamelCase     ,**_lowerCamelCase )

    __lowercase										=							{
        '''candidate_labels''': candidate_labels,
        '''logits''': outputs.logits_per_audio,
    }
    return model_outputs


 def 						_UpperCAmelCase     (self     ,_lowerCamelCase )							->							str:







    '''simple docstring'''





    __lowercase										=							model_outputs.pop('''candidate_labels''' )
    __lowercase										=							model_outputs['''logits'''][0]

    if self.framework == "pt":
       __lowercase										=							logits.softmax(dim=0 )
       __lowercase										=							probs.tolist()
    else:
       raise ValueError('''`tf` framework not supported.''' )

    __lowercase										=							[
        {'''score''': score, '''label''': candidate_label}
        for score, candidate_label in sorted(zip(_lowerCamelCase     ,_lowerCamelCase )     ,key=lambda _lowerCamelCase : -x[0] )
    ]
    return result












'''simple docstring'''



from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


_SCREAMING_SNAKE_CASE					=    '''\
@inproceedings{wang2019glue,
  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},
  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},
  note={In the Proceedings of ICLR.},
  year={2019}
}
'''

_SCREAMING_SNAKE_CASE					=    '''\
GLUE, the General Language Understanding Evaluation benchmark
(https://gluebenchmark.com/) is a collection of resources for training,
evaluating, and analyzing natural language understanding systems.
'''

_SCREAMING_SNAKE_CASE					=    '''
Compute GLUE evaluation metric associated to each GLUE dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
Returns: depending on the GLUE subset, one or several of:
    "accuracy": Accuracy
    "f1": F1 score
    "pearson": Pearson Correlation
    "spearmanr": Spearman Correlation
    "matthews_correlation": Matthew Correlation
Examples:

    >>> glue_metric = datasets.load_metric(\'glue\', \'sst2\')  # \'sst2\' or any of ["mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0}

    >>> glue_metric = datasets.load_metric(\'glue\', \'mrpc\')  # \'mrpc\' or \'qqp\'
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0, \'f1\': 1.0}

    >>> glue_metric = datasets.load_metric(\'glue\', \'stsb\')
    >>> references = [0., 1., 2., 3., 4., 5.]
    >>> predictions = [0., 1., 2., 3., 4., 5.]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print({"pearson": round(results["pearson"], 2), "spearmanr": round(results["spearmanr"], 2)})
    {\'pearson\': 1.0, \'spearmanr\': 1.0}

    >>> glue_metric = datasets.load_metric(\'glue\', \'cola\')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'matthews_correlation\': 1.0}
'''




def    _lowerCAmelCase						(				lowerCamelCase_			:  Any		,       lowerCamelCase_			:  int				):
			return float((preds == labels).mean()				)




def    _lowerCAmelCase						(				lowerCamelCase_			:  List[str]		,       lowerCamelCase_			:  str				):
			__lowercase										=							simple_accuracy(lowerCamelCase_		,       lowerCamelCase_				)
			__lowercase										=							float(fa_score(y_true=lowerCamelCase_		,       y_pred=lowerCamelCase_				)				)
			return {
			    "accuracy": acc,
			    "f1": fa,
			}




def    _lowerCAmelCase						(				lowerCamelCase_			:  List[Any]		,       lowerCamelCase_			:  Any				):
			__lowercase										=							float(pearsonr(lowerCamelCase_		,       lowerCamelCase_				)[0]				)
			__lowercase										=							float(spearmanr(lowerCamelCase_		,       lowerCamelCase_				)[0]				)
			return {
			    "pearson": pearson_corr,
			    "spearmanr": spearman_corr,
			}






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,      _KWARGS_DESCRIPTION						)
class 							__lowercase       (      datasets.Metric						):







	'''simple docstring'''

	def 						_UpperCAmelCase     (self )							->							str:







				'''simple docstring'''





				if self.config_name not in [
				    "sst2",
				    "mnli",
				    "mnli_mismatched",
				    "mnli_matched",
				    "cola",
				    "stsb",
				    "mrpc",
				    "qqp",
				    "qnli",
				    "rte",
				    "wnli",
				    "hans",
				]:
							raise KeyError(
							    '''You should supply a configuration name selected in '''
							    '''["sst2", "mnli", "mnli_mismatched", "mnli_matched", '''
							    '''"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]''' )
				return datasets.MetricInfo(
				    description=_DESCRIPTION     ,citation=_CITATION     ,inputs_description=_KWARGS_DESCRIPTION     ,features=datasets.Features(
				        {
				            '''predictions''': datasets.Value('''int64''' if self.config_name != '''stsb''' else '''float32''' ),
				            '''references''': datasets.Value('''int64''' if self.config_name != '''stsb''' else '''float32''' ),
				        } )     ,codebase_urls=[]     ,reference_urls=[]     ,format='''numpy'''     ,)


	def 						_UpperCAmelCase     (self     ,_lowerCamelCase     ,_lowerCamelCase )							->							Dict:







				'''simple docstring'''





				if self.config_name == "cola":
							return {"matthews_correlation": matthews_corrcoef(_lowerCamelCase     ,_lowerCamelCase )}
				elif self.config_name == "stsb":
							return pearson_and_spearman(_lowerCamelCase     ,_lowerCamelCase )
				elif self.config_name in ["mrpc", "qqp"]:
							return acc_and_fa(_lowerCamelCase     ,_lowerCamelCase )
				elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
							return {"accuracy": simple_accuracy(_lowerCamelCase     ,_lowerCamelCase )}
				else:
							raise KeyError(
							    '''You should supply a configuration name selected in '''
							    '''["sst2", "mnli", "mnli_mismatched", "mnli_matched", '''
							    '''"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]''' )





