


import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCamelCase											=       logging.get_logger(__name__)

lowerCamelCase											=       {
    'asapp/sew-tiny-100k': 'https://huggingface.co/asapp/sew-tiny-100k/resolve/main/config.json',
    # See all SEW models at https://huggingface.co/models?filter=sew
}




class A  (   UpperCamelCase_     ):
      UpperCamelCase__							:  int      ='sew'






      def __init__(					self						:     Union[str, Any]			,   lowercase_						:     Tuple=32			,   lowercase_						:     int=768			,   lowercase_						:     Dict=12			,   lowercase_						:     str=12			,   lowercase_						:     Tuple=3072			,   lowercase_						:     Optional[Any]=2			,   lowercase_						:     Optional[int]="gelu"			,   lowercase_						:     Optional[int]=0.1			,   lowercase_						:     Union[str, Any]=0.1			,   lowercase_						:     Tuple=0.1			,   lowercase_						:     Optional[Any]=0.0			,   lowercase_						:     Optional[Any]=0.1			,   lowercase_						:     List[str]=0.1			,   lowercase_						:     int=0.02			,   lowercase_						:     Optional[int]=1E-5			,   lowercase_						:     Dict="group"			,   lowercase_						:     List[str]="gelu"			,   lowercase_						:     str=(64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512)			,   lowercase_						:     Union[str, Any]=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)			,   lowercase_						:     int=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)			,   lowercase_						:     str=False			,   lowercase_						:     Union[str, Any]=128			,   lowercase_						:     List[str]=16			,   lowercase_						:     Union[str, Any]=True			,   lowercase_						:     List[Any]=0.05			,   lowercase_						:     int=10			,   lowercase_						:     Tuple=2			,   lowercase_						:     Any=0.0			,   lowercase_						:     List[Any]=10			,   lowercase_						:     Optional[int]=0			,   lowercase_						:     int="mean"			,   lowercase_						:     Tuple=False			,   lowercase_						:     Dict=False			,   lowercase_						:     Optional[Any]=256			,   lowercase_						:     Optional[Any]=0			,   lowercase_						:     int=1			,   lowercase_						:     Union[str, Any]=2			,   **lowercase_						:     List[str]			,   )					->						Tuple:
             """simple docstring"""




             super().__init__(**lowercase_			,   pad_token_id=lowercase_			,   bos_token_id=lowercase_			,   eos_token_id=lowercase_ )
             _lowerCamelCase       :		int		=hidden_size
             _lowerCamelCase       :		str		=feat_extract_norm
             _lowerCamelCase       :		List[str]		=feat_extract_activation
             _lowerCamelCase       :		Optional[int]		=list(lowercase_ )
             _lowerCamelCase       :		Dict		=list(lowercase_ )
             _lowerCamelCase       :		Any		=list(lowercase_ )
             _lowerCamelCase       :		str		=conv_bias
             _lowerCamelCase       :		Union[str, Any]		=num_conv_pos_embeddings
             _lowerCamelCase       :		Optional[Any]		=num_conv_pos_embedding_groups
             _lowerCamelCase       :		List[Any]		=len(self.conv_dim )
             _lowerCamelCase       :		Dict		=num_hidden_layers
             _lowerCamelCase       :		Any		=intermediate_size
             _lowerCamelCase       :		List[str]		=squeeze_factor
             _lowerCamelCase       :		Optional[Any]		=hidden_act
             _lowerCamelCase       :		Dict		=num_attention_heads
             _lowerCamelCase       :		str		=hidden_dropout
             _lowerCamelCase       :		Optional[int]		=attention_dropout
             _lowerCamelCase       :		Union[str, Any]		=activation_dropout
             _lowerCamelCase       :		Any		=feat_proj_dropout
             _lowerCamelCase       :		Dict		=final_dropout
             _lowerCamelCase       :		Tuple		=layerdrop
             _lowerCamelCase       :		Tuple		=layer_norm_eps
             _lowerCamelCase       :		Optional[int]		=initializer_range
             _lowerCamelCase       :		Tuple		=vocab_size

             if (
                 (len(self.conv_stride ) != self.num_feat_extract_layers)
                 or (len(self.conv_kernel ) != self.num_feat_extract_layers)
                 or (len(self.conv_dim ) != self.num_feat_extract_layers)
             ):
                    raise ValueError(
                        'Configuration for convolutional layers is incorrect.'
                        'It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,'
                        F'''but is `len(config.conv_dim) = {len(self.conv_dim )}`, `len(config.conv_stride)'''
                        F'''= {len(self.conv_stride )}`, `len(config.conv_kernel) = {len(self.conv_kernel )}`.''' )

             # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
             _lowerCamelCase       :		List[str]		=apply_spec_augment
             _lowerCamelCase       :		str		=mask_time_prob
             _lowerCamelCase       :		Dict		=mask_time_length
             _lowerCamelCase       :		Dict		=mask_time_min_masks
             _lowerCamelCase       :		List[str]		=mask_feature_prob
             _lowerCamelCase       :		Dict		=mask_feature_length
             _lowerCamelCase       :		Tuple		=mask_feature_min_masks

             # ctc loss
             _lowerCamelCase       :		Optional[int]		=ctc_loss_reduction
             _lowerCamelCase       :		Tuple		=ctc_zero_infinity

             # sequence classification
             _lowerCamelCase       :		Optional[Any]		=use_weighted_layer_sum
             _lowerCamelCase       :		List[str]		=classifier_proj_size






      @property
      def        lowerCamelCase       (					self						:     Dict )					->						Dict:
             """simple docstring"""




             return functools.reduce(operator.mul			,   self.conv_stride			,   1 )






from sklearn.metrics import mean_squared_error

import datasets


lowerCamelCase											=       '\\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n'

lowerCamelCase											=       '\\nMean Squared Error(MSE) is the average of the square of difference between the predicted\nand actual values.\n'


lowerCamelCase											=       '\nArgs:\n    predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Estimated target values.\n    references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Ground truth (correct) target values.\n    sample_weight: array-like of shape (n_samples,), default=None\n        Sample weights.\n    multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n        Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n        "raw_values" : Returns a full set of errors in case of multioutput input.\n\n        "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\n    squared : bool, default=True\n        If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.\n\nReturns:\n    mse : mean squared error.\nExamples:\n\n    >>> mse_metric = datasets.load_metric("mse")\n    >>> predictions = [2.5, 0.0, 2, 8]\n    >>> references = [3, -0.5, 2, 7]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.375}\n    >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)\n    >>> print(rmse_result)\n    {\'mse\': 0.6123724356957945}\n\n    If you\'re using multi-dimensional lists, then set the config as follows :\n\n    >>> mse_metric = datasets.load_metric("mse", "multilist")\n    >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n    >>> references = [[0, 2], [-1, 2], [8, -5]]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.7083333333333334}\n    >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n    >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n    {\'mse\': array([0.41666667, 1. ])}\n'




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






      def        lowerCamelCase       (					self						:     List[Any] )					->						List[str]:
             """simple docstring"""




             return datasets.MetricInfo(
                 description=_DESCRIPTION			,   citation=_CITATION			,   inputs_description=_KWARGS_DESCRIPTION			,   features=datasets.Features(self._get_feature_types() )			,   reference_urls=[
                     'https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'
                 ]			,   )






      def        lowerCamelCase       (					self						:     Tuple )					->						Optional[int]:
             """simple docstring"""




             if self.config_name == "multilist":
                    return {
                        "predictions": datasets.Sequence(datasets.Value('float' ) ),
                        "references": datasets.Sequence(datasets.Value('float' ) ),
                    }
             else:
                    return {
                        "predictions": datasets.Value('float' ),
                        "references": datasets.Value('float' ),
                    }






      def        lowerCamelCase       (					self						:     List[Any]			,   lowercase_						:     List[Any]			,   lowercase_						:     Tuple			,   lowercase_						:     List[str]=None			,   lowercase_						:     Union[str, Any]="uniform_average"			,   lowercase_						:     Tuple=True )					->						Any:
             """simple docstring"""




             _lowerCamelCase       :		List[str]		=mean_squared_error(
                 lowercase_			,   lowercase_			,   sample_weight=lowercase_			,   multioutput=lowercase_			,   squared=lowercase_ )

             return {"mse": mse}


