code: 
  
  from typing import List, Optional, Union
  
  import numpy as np
  
  from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
  from ...feature_extraction_utils import BatchFeature
  from ...utils import PaddingStrategy, TensorType, logging
  
  
  lowerCamelCase     =      logging.get_logger(__name__)
  
  
  
  
  
  
  
  class 		__magic_name__    (							lowerCamelCase__							):
  
     '''simple docstring'''
  
  
  
  
     lowerCamelCase__				:			Any												=     ['input_values', 'attention_mask']
  
  
  
     def __init__(       self,					lowercase_=1,					lowercase_=16000,					lowercase_=0.0,					lowercase_=False,					lowercase_=True,					**lowercase_,					)							->					Tuple:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       super().__init__(feature_size=lowercase_,					sampling_rate=lowercase_,					padding_value=lowercase_,					**lowercase_ )
       a__						=return_attention_mask
       a__						=do_normalize
  
  
  
     @staticmethod
     def 				_UpperCAmelCase				(       lowercase_,					lowercase_,					lowercase_ = 0.0 )							->					List[np.ndarray]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       if attention_mask is not None:
         a__						=np.array(lowercase_,					np.intaa )
         a__						=[]
  
         for vector, length in zip(lowercase_,					attention_mask.sum(-1 ) ):
           a__						=(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7 )
           if length < normed_slice.shape[0]:
             a__						=padding_value
  
           normed_input_values.append(lowercase_ )
       else:
         a__						=[(x - x.mean()) / np.sqrt(x.var() + 1E-7 ) for x in input_values]
  
       return normed_input_values
  
  
  
     def __call__(       self,					lowercase_,					lowercase_ = False,					lowercase_ = None,					lowercase_ = False,					lowercase_ = None,					lowercase_ = None,					lowercase_ = None,					lowercase_ = None,					**lowercase_,					)							->					BatchFeature:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       if sampling_rate is not None:
         if sampling_rate != self.sampling_rate:
           raise ValueError(
               F"""The model corresponding to this feature extractor: {self} was trained using a sampling rate of"""
               F""" {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with"""
               F""" {self.sampling_rate} and not {sampling_rate}.""" )
       else:
         logger.warning(
             '''It is strongly recommended to pass the ``sampling_rate`` argument to this function. '''
             '''Failing to do so can result in silent errors that might be hard to debug.''' )
  
       a__						=isinstance(lowercase_,					np.ndarray ) and len(raw_speech.shape ) > 1
       if is_batched_numpy and len(raw_speech.shape ) > 2:
         raise ValueError(F"""Only mono-channel audio is supported for input to {self}""" )
       a__						=is_batched_numpy or (
           isinstance(lowercase_,					(list, tuple) ) and (isinstance(raw_speech[0],					(np.ndarray, tuple, list) ))
       )
  
       # always return batch
       if not is_batched:
         a__						=[raw_speech]
  
       # convert into correct format for padding
       a__						=BatchFeature({'''input_values''': raw_speech} )
  
       a__						=self.pad(
           lowercase_,					padding=lowercase_,					max_length=lowercase_,					truncation=lowercase_,					pad_to_multiple_of=lowercase_,					return_attention_mask=lowercase_,					)
  
       # convert input values to correct format
       a__						=padded_inputs['''input_values''']
       if not isinstance(input_values[0],					np.ndarray ):
         a__						=[np.asarray(lowercase_,					dtype=np.floataa ) for array in input_values]
       elif (
           not isinstance(lowercase_,					np.ndarray )
           and isinstance(input_values[0],					np.ndarray )
           and input_values[0].dtype is np.dtype(np.floataa )
       ):
         a__						=[array.astype(np.floataa ) for array in input_values]
       elif isinstance(lowercase_,					np.ndarray ) and input_values.dtype is np.dtype(np.floataa ):
         a__						=input_values.astype(np.floataa )
  
       # convert attention_mask to correct format
       a__						=padded_inputs.get('''attention_mask''' )
       if attention_mask is not None:
         a__						=[np.asarray(lowercase_,					dtype=np.intaa ) for array in attention_mask]
  
       # zero-mean and unit-variance normalization
       if self.do_normalize:
         a__						=(
             attention_mask
             if self._get_padding_strategies(lowercase_,					max_length=lowercase_ ) is not PaddingStrategy.DO_NOT_PAD
             else None
         )
         a__						=self.zero_mean_unit_var_norm(
             padded_inputs['''input_values'''],					attention_mask=lowercase_,					padding_value=self.padding_value )
  
       if return_tensors is not None:
         a__						=padded_inputs.convert_to_tensors(lowercase_ )
  
       return padded_inputs
  
style_context: 
  
  import torch
  from transformers import AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments
  
  import datasets
  
  
  lowerCamelCase     =      '''\
  @article{eddine2021frugalscore,
    title={FrugalScore: Learning Cheaper, Lighter and Faster Evaluation Metrics for Automatic Text Generation},
    author={Eddine, Moussa Kamal and Shang, Guokan and Tixier, Antoine J-P and Vazirgiannis, Michalis},
    journal={arXiv preprint arXiv:2110.08559},
    year={2021}
  }
  '''
  
  lowerCamelCase     =      '''\
  FrugalScore is a reference-based metric for NLG models evaluation. It is based on a distillation approach that allows to learn a fixed, low cost version of any expensive NLG metric, while retaining most of its original performance.
  '''
  
  
  lowerCamelCase     =      '''
  Calculates how good are predictions given some references, using certain scores.
  Args:
      predictions (list of str): list of predictions to score. Each predictions
          should be a string.
      references (list of str): list of reference for each prediction. Each
          reference should be a string.
      batch_size (int): the batch size for predictions.
      max_length (int): maximum sequence length.
      device (str): either gpu or cpu
  Returns:
      scores (list of int): list of scores.
  Examples:
      >>> frugalscore = datasets.load_metric("frugalscore")
      >>> results = frugalscore.compute(predictions=[\'hello there\', \'huggingface\'], references=[\'hello world\', \'hugging face\'])
      >>> print([round(s, 3) for s in results["scores"]])
      [0.631, 0.645]
  '''
  
  
  
  
  
  
  
  @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION	, _KWARGS_DESCRIPTION							)
  class 		__magic_name__    (							datasets.Metric							):
  
     '''simple docstring'''
  
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return datasets.MetricInfo(
           description=_DESCRIPTION,					citation=_CITATION,					inputs_description=_KWARGS_DESCRIPTION,					features=datasets.Features(
               {
                   '''predictions''': datasets.Value('''string''' ),
                   '''references''': datasets.Value('''string''' ),
               } ),					homepage='''https://github.com/moussaKam/FrugalScore''',					)
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       if self.config_name == "default":
         a__						='''moussaKam/frugalscore_tiny_bert-base_bert-score'''
       else:
         a__						=self.config_name
       a__						=AutoModelForSequenceClassification.from_pretrained(lowercase_ )
       a__						=AutoTokenizer.from_pretrained(lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_,					lowercase_=32,					lowercase_=128,					lowercase_=None,					)							->					Union[str, Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       assert len(lowercase_ ) == len(
           lowercase_ ), "predictions and references should have the same number of sentences."
       if device is not None:
         assert device in ["gpu", "cpu"], "device should be either gpu or cpu."
       else:
         a__						='''gpu''' if torch.cuda.is_available() else '''cpu'''
       a__						=TrainingArguments(
           '''trainer''',					fpaa=(device == '''gpu'''),					per_device_eval_batch_size=lowercase_,					report_to='''all''',					no_cuda=(device == '''cpu'''),					log_level='''warning''',					)
       a__						={'''sentence1''': predictions, '''sentence2''': references}
       a__						=datasets.Dataset.from_dict(lowercase_ )
  
       def tokenize_function(lowercase_ ):
         return self.tokenizer(
             data['''sentence1'''],					data['''sentence2'''],					max_length=lowercase_,					truncation=lowercase_,					padding=lowercase_ )
  
       a__						=raw_datasets.map(lowercase_,					batched=lowercase_ )
       tokenized_datasets.remove_columns(['''sentence1''', '''sentence2'''] )
       a__						=Trainer(self.model,					lowercase_,					tokenizer=self.tokenizer )
       a__						=trainer.predict(lowercase_ )
       return {"scores": list(predictions.predictions.squeeze(-1 ) )}
  