

from sklearn.metrics import fa_score

import datasets


a_						     =    '\nThe F1 score is the harmonic mean of the precision and recall. It can be computed with the equation:\nF1 = 2 * (precision * recall) / (precision + recall)\n'


a_						     =    '\nArgs:\n    predictions (`list` of `int`): Predicted labels.\n    references (`list` of `int`): Ground truth labels.\n    labels (`list` of `int`): The set of labels to include when `average` is not set to `\'binary\'`, and the order of the labels if `average` is `None`. Labels present in the data can be excluded, for example to calculate a multiclass average ignoring a majority negative class. Labels not present in the data will result in 0 components in a macro average. For multilabel targets, labels are column indices. By default, all labels in `predictions` and `references` are used in sorted order. Defaults to None.\n    pos_label (`int`): The class to be considered the positive class, in the case where `average` is set to `binary`. Defaults to 1.\n    average (`string`): This parameter is required for multiclass/multilabel targets. If set to `None`, the scores for each class are returned. Otherwise, this determines the type of averaging performed on the data. Defaults to `\'binary\'`.\n\n        - \'binary\': Only report results for the class specified by `pos_label`. This is applicable only if the classes found in `predictions` and `references` are binary.\n        - \'micro\': Calculate metrics globally by counting the total true positives, false negatives and false positives.\n        - \'macro\': Calculate metrics for each label, and find their unweighted mean. This does not take label imbalance into account.\n        - \'weighted\': Calculate metrics for each label, and find their average weighted by support (the number of true instances for each label). This alters `\'macro\'` to account for label imbalance. This option can result in an F-score that is not between precision and recall.\n        - \'samples\': Calculate metrics for each instance, and find their average (only meaningful for multilabel classification).\n    sample_weight (`list` of `float`): Sample weights Defaults to None.\n\nReturns:\n    f1 (`float` or `array` of `float`): F1 score or list of f1 scores, depending on the value passed to `average`. Minimum possible value is 0. Maximum possible value is 1. Higher f1 scores are better.\n\nExamples:\n\n    Example 1-A simple binary example\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0])\n        >>> print(results)\n        {\'f1\': 0.5}\n\n    Example 2-The same simple binary example as in Example 1, but with `pos_label` set to `0`.\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], pos_label=0)\n        >>> print(round(results[\'f1\'], 2))\n        0.67\n\n    Example 3-The same simple binary example as in Example 1, but with `sample_weight` included.\n        >>> f1_metric = datasets.load_metric("f1")\n        >>> results = f1_metric.compute(references=[0, 1, 0, 1, 0], predictions=[0, 0, 1, 1, 0], sample_weight=[0.9, 0.5, 3.9, 1.2, 0.3])\n        >>> print(round(results[\'f1\'], 2))\n        0.35\n\n    Example 4-A multiclass example, with different values for the `average` input.\n        >>> predictions = [0, 2, 1, 0, 0, 1]\n        >>> references = [0, 1, 2, 0, 1, 2]\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="macro")\n        >>> print(round(results[\'f1\'], 2))\n        0.27\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="micro")\n        >>> print(round(results[\'f1\'], 2))\n        0.33\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average="weighted")\n        >>> print(round(results[\'f1\'], 2))\n        0.27\n        >>> results = f1_metric.compute(predictions=predictions, references=references, average=None)\n        >>> print(results)\n        {\'f1\': array([0.8, 0. , 0. ])}\n'


a_						     =    '\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'






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,	_KWARGS_DESCRIPTION   )
class 					_UpperCamelCase							(							datasets.Metric   ):
			'''simple docstring'''







			def 							__UpperCamelCase (			self							: Any	)							->       Optional[Any]:

				"""simple docstring"""

				return datasets.MetricInfo(
				    description=_DESCRIPTION      ,      citation=_CITATION      ,      inputs_description=_KWARGS_DESCRIPTION      ,      features=datasets.Features(
				        {
				            "predictions": datasets.Sequence(datasets.Value("int32"	)	),
				            "references": datasets.Sequence(datasets.Value("int32"	)	),
				        }
				        if self.config_name == "multilabel"
				        else {
				            "predictions": datasets.Value("int32"	),
				            "references": datasets.Value("int32"	),
				        }	)      ,      reference_urls=["https://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html"]      ,      )






			def 							__UpperCamelCase (			self							: List[Any]      ,      a							: Optional[Any]      ,      a							: List[Any]      ,      a							: Dict=None      ,      a							: Optional[Any]=1      ,      a							: List[str]="binary"      ,      a							: str=None	)							->       Optional[int]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE   :      List[Any]				     =       fa_score(
				    UpperCAmelCase__      ,      UpperCAmelCase__      ,      labels=UpperCAmelCase__      ,      pos_label=UpperCAmelCase__      ,      average=UpperCAmelCase__      ,      sample_weight=UpperCAmelCase__	)
				return {"f1": float(UpperCAmelCase__	) if score.size == 1 else score}


import functools
import operator

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


a_						     =    logging.get_logger(__name__)

a_						     =    {
    'microsoft/wavlm-base': 'https://huggingface.co/microsoft/wavlm-base/resolve/main/config.json',
    # See all WavLM models at https://huggingface.co/models?filter=wavlm
}






class _UpperCamelCase							(							__A   ):
			'''simple docstring'''







			lowerCamelCase__           ='wavlm'
			def __init__(			self							: Optional[int]      ,      a							: Optional[Any]=32      ,      a							: int=768      ,      a							: Tuple=12      ,      a							: List[str]=12      ,      a							: str=3072      ,      a							: Any="gelu"      ,      a							: Dict=0.1      ,      a							: int=0.1      ,      a							: str=0.1      ,      a							: Optional[Any]=0.0      ,      a							: Any=0.1      ,      a							: Any=0.1      ,      a							: List[str]=0.02      ,      a							: List[Any]=1e-5      ,      a							: Any="group"      ,      a							: Optional[int]="gelu"      ,      a							: List[str]=(512, 512, 512, 512, 512, 512, 512)      ,      a							: Any=(5, 2, 2, 2, 2, 2, 2)      ,      a							: Union[str, Any]=(10, 3, 3, 3, 3, 2, 2)      ,      a							: Optional[Any]=False      ,      a							: Dict=128      ,      a							: Optional[Any]=16      ,      a							: Optional[Any]=320      ,      a							: str=800      ,      a							: Optional[int]=False      ,      a							: Tuple=True      ,      a							: Optional[Any]=0.05      ,      a							: Any=10      ,      a							: Optional[int]=2      ,      a							: Dict=0.0      ,      a							: str=10      ,      a							: Tuple=320      ,      a							: Optional[int]=2      ,      a							: int=0.1      ,      a							: List[str]=100      ,      a							: Tuple=256      ,      a							: str=256      ,      a							: Tuple=0.1      ,      a							: str="mean"      ,      a							: int=False      ,      a							: int=False      ,      a							: Optional[Any]=256      ,      a							: Any=(512, 512, 512, 512, 1500)      ,      a							: Tuple=(5, 3, 3, 1, 1)      ,      a							: str=(1, 2, 3, 1, 1)      ,      a							: Optional[Any]=512      ,      a							: Optional[Any]=80      ,      a							: Tuple=0      ,      a							: Any=1      ,      a							: Optional[Any]=2      ,      a							: int=False      ,      a							: Dict=3      ,      a							: Any=2      ,      a							: List[Any]=3      ,      a							: int=None      ,      **a							: Any      ,      )							->       Dict:

				"""simple docstring"""

				super().__init__(**a      ,      pad_token_id=a      ,      bos_token_id=a      ,      eos_token_id=a	)
				SCREAMING_SNAKE_CASE   :      List[str]				     =       hidden_size
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       feat_extract_norm
				SCREAMING_SNAKE_CASE   :      Any				     =       feat_extract_activation
				SCREAMING_SNAKE_CASE   :      Any				     =       list(a	)
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       list(a	)
				SCREAMING_SNAKE_CASE   :      Optional[Any]				     =       list(a	)
				SCREAMING_SNAKE_CASE   :      Any				     =       conv_bias
				SCREAMING_SNAKE_CASE   :      str				     =       num_buckets
				SCREAMING_SNAKE_CASE   :      str				     =       max_bucket_distance
				SCREAMING_SNAKE_CASE   :      List[str]				     =       num_conv_pos_embeddings
				SCREAMING_SNAKE_CASE   :      Any				     =       num_conv_pos_embedding_groups
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       len(self.conv_dim	)
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       num_hidden_layers
				SCREAMING_SNAKE_CASE   :      List[str]				     =       intermediate_size
				SCREAMING_SNAKE_CASE   :      Dict				     =       hidden_act
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       num_attention_heads
				SCREAMING_SNAKE_CASE   :      int				     =       hidden_dropout
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       attention_dropout
				SCREAMING_SNAKE_CASE   :      List[str]				     =       activation_dropout
				SCREAMING_SNAKE_CASE   :      int				     =       feat_proj_dropout
				SCREAMING_SNAKE_CASE   :      Any				     =       final_dropout
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       layerdrop
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       layer_norm_eps
				SCREAMING_SNAKE_CASE   :      int				     =       initializer_range
				SCREAMING_SNAKE_CASE   :      Dict				     =       num_ctc_classes
				SCREAMING_SNAKE_CASE   :      Tuple				     =       vocab_size
				SCREAMING_SNAKE_CASE   :      int				     =       do_stable_layer_norm
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       use_weighted_layer_sum
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       classifier_proj_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)`, but is `len(config.conv_dim) ="
					    F" {len(self.conv_dim	)}`, `len(config.conv_stride) = {len(self.conv_stride	)}`,"
					    F" `len(config.conv_kernel) = {len(self.conv_kernel	)}`."	)

				# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
				SCREAMING_SNAKE_CASE   :      int				     =       apply_spec_augment
				SCREAMING_SNAKE_CASE   :      int				     =       mask_time_prob
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       mask_time_length
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       mask_time_min_masks
				SCREAMING_SNAKE_CASE   :      Tuple				     =       mask_feature_prob
				SCREAMING_SNAKE_CASE   :      List[str]				     =       mask_feature_length

				# parameters for pretraining with codevector quantized representations
				SCREAMING_SNAKE_CASE   :      str				     =       num_codevectors_per_group
				SCREAMING_SNAKE_CASE   :      Dict				     =       num_codevector_groups
				SCREAMING_SNAKE_CASE   :      Tuple				     =       contrastive_logits_temperature
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       num_negatives
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       codevector_dim
				SCREAMING_SNAKE_CASE   :      int				     =       proj_codevector_dim
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       diversity_loss_weight

				# ctc loss
				SCREAMING_SNAKE_CASE   :      Any				     =       ctc_loss_reduction
				SCREAMING_SNAKE_CASE   :      Dict				     =       ctc_zero_infinity

				# adapter
				SCREAMING_SNAKE_CASE   :      Any				     =       add_adapter
				SCREAMING_SNAKE_CASE   :      Optional[int]				     =       adapter_kernel_size
				SCREAMING_SNAKE_CASE   :      Any				     =       adapter_stride
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       num_adapter_layers
				SCREAMING_SNAKE_CASE   :      int				     =       output_hidden_size or hidden_size

				# SequenceClassification-specific parameter. Feel free to ignore for other classes.
				SCREAMING_SNAKE_CASE   :      List[Any]				     =       classifier_proj_size

				# XVector-specific parameters. Feel free to ignore for other classes.
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       list(a	)
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       list(a	)
				SCREAMING_SNAKE_CASE   :      Union[str, Any]				     =       list(a	)
				SCREAMING_SNAKE_CASE   :      Tuple				     =       xvector_output_dim






			@property
			def 							__UpperCamelCase (			self							: int	)							->       Union[str, Any]:

				"""simple docstring"""

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