

'''simple docstring'''




from dataclasses import dataclass
from typing import Any, Dict, Optional

import torch
import torch.nn.functional as F
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..models.embeddings import ImagePositionalEmbeddings
from ..utils import BaseOutput, deprecate
from .attention import BasicTransformerBlock
from .embeddings import PatchEmbed
from .modeling_utils import ModelMixin



@dataclass
class     lowercase_		(						a	):

  '''simple docstring'''





  __lowerCAmelCase   :	torch.FloatTensor




class     lowercase_		(						a	,    a	):

  '''simple docstring'''





  @register_to_config
  def __init__(       self				,	a_ = 1_6				,	a_ = 8_8				,	a_ = None				,	a_ = None				,	a_ = 1				,	a_ = 0.0				,	a_ = 3_2				,	a_ = None				,	a_ = False				,	a_ = None				,	a_ = None				,	a_ = None				,	a_ = "geglu"				,	a_ = None				,	a_ = False				,	a_ = False				,	a_ = False				,	a_ = "layer_norm"				,	a_ = True				,	)							->			List[str]:


    """simple docstring"""
    super().__init__()
    UpperCAmelCase  							=		use_linear_projection
    UpperCAmelCase  							=		num_attention_heads
    UpperCAmelCase  							=		attention_head_dim
    UpperCAmelCase  							=		num_attention_heads * attention_head_dim

    # 1. Transformer2DModel can process both standard continuous images of shape `(batch_size, num_channels, width, height)` as well as quantized image embeddings of shape `(batch_size, num_image_vectors)`
    # Define whether input is continuous or discrete depending on configuration
    UpperCAmelCase  							=		(in_channels is not None) and (patch_size is None)
    UpperCAmelCase  							=		num_vector_embeds is not None
    UpperCAmelCase  							=		in_channels is not None and patch_size is not None

    if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
      UpperCAmelCase  							=		(
          F'''The configuration file of this model: {self.__class__} is outdated. `norm_type` is either not set or'''
          ' incorrectly set to `\'layer_norm\'`.Make sure to set `norm_type` to `\'ada_norm\'` in the config.'
          ' Please make sure to update the config accordingly as leaving `norm_type` might led to incorrect'
          ' results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it'
          ' would be very nice if you could open a Pull request for the `transformer/config.json` file'
      )
      deprecate('norm_type!=num_embeds_ada_norm'				,	'1.0.0'				,	a_				,	standard_warn=a_       )
      UpperCAmelCase  							=		'ada_norm'

    if self.is_input_continuous and self.is_input_vectorized:
      raise ValueError(
          F'''Cannot define both `in_channels`: {in_channels} and `num_vector_embeds`: {num_vector_embeds}. Make'''
          ' sure that either `in_channels` or `num_vector_embeds` is None.'       )
    elif self.is_input_vectorized and self.is_input_patches:
      raise ValueError(
          F'''Cannot define both `num_vector_embeds`: {num_vector_embeds} and `patch_size`: {patch_size}. Make'''
          ' sure that either `num_vector_embeds` or `num_patches` is None.'       )
    elif not self.is_input_continuous and not self.is_input_vectorized and not self.is_input_patches:
      raise ValueError(
          F'''Has to define `in_channels`: {in_channels}, `num_vector_embeds`: {num_vector_embeds}, or patch_size:'''
          F''' {patch_size}. Make sure that `in_channels`, `num_vector_embeds` or `num_patches` is not None.'''       )

    # 2. Define input layers
    if self.is_input_continuous:
      UpperCAmelCase  							=		in_channels

      UpperCAmelCase  							=		torch.nn.GroupNorm(num_groups=a_				,	num_channels=a_				,	eps=1E-6				,	affine=a_       )
      if use_linear_projection:
        UpperCAmelCase  							=		nn.Linear(a_				,	a_       )
      else:
        UpperCAmelCase  							=		nn.Convad(a_				,	a_				,	kernel_size=1				,	stride=1				,	padding=0       )
    elif self.is_input_vectorized:
      assert sample_size is not None, "Transformer2DModel over discrete input must provide sample_size"
      assert num_vector_embeds is not None, "Transformer2DModel over discrete input must provide num_embed"

      UpperCAmelCase  							=		sample_size
      UpperCAmelCase  							=		sample_size
      UpperCAmelCase  							=		num_vector_embeds
      UpperCAmelCase  							=		self.height * self.width

      UpperCAmelCase  							=		ImagePositionalEmbeddings(
          num_embed=a_				,	embed_dim=a_				,	height=self.height				,	width=self.width       )
    elif self.is_input_patches:
      assert sample_size is not None, "Transformer2DModel over patched input must provide sample_size"

      UpperCAmelCase  							=		sample_size
      UpperCAmelCase  							=		sample_size

      UpperCAmelCase  							=		patch_size
      UpperCAmelCase  							=		PatchEmbed(
          height=a_				,	width=a_				,	patch_size=a_				,	in_channels=a_				,	embed_dim=a_				,	)

    # 3. Define transformers blocks
    UpperCAmelCase  							=		nn.ModuleList(
        [
            BasicTransformerBlock(
                a_				,	a_				,	a_				,	dropout=a_				,	cross_attention_dim=a_				,	activation_fn=a_				,	num_embeds_ada_norm=a_				,	attention_bias=a_				,	only_cross_attention=a_				,	upcast_attention=a_				,	norm_type=a_				,	norm_elementwise_affine=a_				,	)
            for d in range(a_       )
        ]       )

    # 4. Define output layers
    UpperCAmelCase  							=		in_channels if out_channels is None else out_channels
    if self.is_input_continuous:
      # TODO: should use out_channels for continuous projections
      if use_linear_projection:
        UpperCAmelCase  							=		nn.Linear(a_				,	a_       )
      else:
        UpperCAmelCase  							=		nn.Convad(a_				,	a_				,	kernel_size=1				,	stride=1				,	padding=0       )
    elif self.is_input_vectorized:
      UpperCAmelCase  							=		nn.LayerNorm(a_       )
      UpperCAmelCase  							=		nn.Linear(a_				,	self.num_vector_embeds - 1       )
    elif self.is_input_patches:
      UpperCAmelCase  							=		nn.LayerNorm(a_				,	elementwise_affine=a_				,	eps=1E-6       )
      UpperCAmelCase  							=		nn.Linear(a_				,	2 * inner_dim       )
      UpperCAmelCase  							=		nn.Linear(a_				,	patch_size * patch_size * self.out_channels       )





  def   snake_case_     (       self				,	a_				,	a_ = None				,	a_ = None				,	a_ = None				,	a_ = None				,	a_ = None				,	a_ = None				,	a_ = True				,	)							->			Optional[int]:


    """simple docstring"""
    # ensure attention_mask is a bias, and give it a singleton query_tokens dimension.
    #   we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward.
    #   we can tell by counting dims; if ndim == 2: it's a mask rather than a bias.
    # expects mask of shape:
    #   [batch, key_tokens]
    # adds singleton query_tokens dimension:
    #   [batch,                    1, key_tokens]
    # this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes:
    #   [batch,  heads, query_tokens, key_tokens] (e.g. torch sdp attn)
    #   [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn)
    if attention_mask is not None and attention_mask.ndim == 2:
      # assume that mask is expressed as:
      #   (1 = keep,      0 = discard)
      # convert mask into a bias that can be added to attention scores:
      #       (keep = +0,     discard = -10000.0)
      UpperCAmelCase  							=		(1 - attention_mask.to(hidden_states.dtype       )) * -1_0000.0
      UpperCAmelCase  							=		attention_mask.unsqueeze(1       )

    # convert encoder_attention_mask to a bias the same way we do for attention_mask
    if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2:
      UpperCAmelCase  							=		(1 - encoder_attention_mask.to(hidden_states.dtype       )) * -1_0000.0
      UpperCAmelCase  							=		encoder_attention_mask.unsqueeze(1       )

    # 1. Input
    if self.is_input_continuous:
      UpperCAmelCase							, UpperCAmelCase							, UpperCAmelCase							, UpperCAmelCase  							=		hidden_states.shape
      UpperCAmelCase  							=		hidden_states

      UpperCAmelCase  							=		self.norm(a_       )
      if not self.use_linear_projection:
        UpperCAmelCase  							=		self.proj_in(a_       )
        UpperCAmelCase  							=		hidden_states.shape[1]
        UpperCAmelCase  							=		hidden_states.permute(0				,	2				,	3				,	1       ).reshape(a_				,	height * width				,	a_       )
      else:
        UpperCAmelCase  							=		hidden_states.shape[1]
        UpperCAmelCase  							=		hidden_states.permute(0				,	2				,	3				,	1       ).reshape(a_				,	height * width				,	a_       )
        UpperCAmelCase  							=		self.proj_in(a_       )
    elif self.is_input_vectorized:
      UpperCAmelCase  							=		self.latent_image_embedding(a_       )
    elif self.is_input_patches:
      UpperCAmelCase  							=		self.pos_embed(a_       )

    # 2. Blocks
    for block in self.transformer_blocks:
      UpperCAmelCase  							=		block(
          a_				,	attention_mask=a_				,	encoder_hidden_states=a_				,	encoder_attention_mask=a_				,	timestep=a_				,	cross_attention_kwargs=a_				,	class_labels=a_				,	)

    # 3. Output
    if self.is_input_continuous:
      if not self.use_linear_projection:
        UpperCAmelCase  							=		hidden_states.reshape(a_				,	a_				,	a_				,	a_       ).permute(0				,	3				,	1				,	2       ).contiguous()
        UpperCAmelCase  							=		self.proj_out(a_       )
      else:
        UpperCAmelCase  							=		self.proj_out(a_       )
        UpperCAmelCase  							=		hidden_states.reshape(a_				,	a_				,	a_				,	a_       ).permute(0				,	3				,	1				,	2       ).contiguous()

      UpperCAmelCase  							=		hidden_states + residual
    elif self.is_input_vectorized:
      UpperCAmelCase  							=		self.norm_out(a_       )
      UpperCAmelCase  							=		self.out(a_       )
      # (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
      UpperCAmelCase  							=		logits.permute(0				,	2				,	1       )

      # log(p(x_0))
      UpperCAmelCase  							=		F.log_softmax(logits.double()				,	dim=1       ).float()
    elif self.is_input_patches:
      # TODO: cleanup!
      UpperCAmelCase  							=		self.transformer_blocks[0].norma.emb(
          a_				,	a_				,	hidden_dtype=hidden_states.dtype       )
      UpperCAmelCase							, UpperCAmelCase  							=		self.proj_out_a(F.silu(a_       )       ).chunk(2				,	dim=1       )
      UpperCAmelCase  							=		self.norm_out(a_       ) * (1 + scale[:, None]) + shift[:, None]
      UpperCAmelCase  							=		self.proj_out_a(a_       )

      # unpatchify
      UpperCAmelCase  							=		UpperCAmelCase  							=		int(hidden_states.shape[1] ** 0.5       )
      UpperCAmelCase  							=		hidden_states.reshape(
          shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels)       )
      UpperCAmelCase  							=		torch.einsum('nhwpqc->nchpwq'				,	a_       )
      UpperCAmelCase  							=		hidden_states.reshape(
          shape=(-1, self.out_channels, height * self.patch_size, width * self.patch_size)       )

    if not return_dict:
      return (output,)

    return TransformeraDModelOutput(sample=a_       )





'''simple docstring'''




from typing import List

from packaging import version
from sklearn.metrics import fa_score

import datasets
from datasets.config import PY_VERSION


if PY_VERSION < version.parse('3.8'):
  import importlib_metadata
else:
  import importlib.metadata as importlib_metadata


# TODO(Patrick/Anton)
_a			:	List[Any]								=  '\\n'

_a			:	Optional[Any]								=  '\\n    XTREME-S is a benchmark to evaluate universal cross-lingual speech representations in many languages.\n    XTREME-S covers four task families: speech recognition, classification, speech-to-text translation and retrieval.\n'

_a			:	Dict								=  '\nCompute XTREME-S evaluation metric associated to each XTREME-S dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    bleu_kwargs: optional dict of keywords to be passed when computing \'bleu\'.\n        Keywords include Dict can be one of \'smooth_method\', \'smooth_value\', \'force\', \'lowercase\',\n        \'tokenize\', \'use_effective_order\'.\n    wer_kwargs: optional dict of keywords to be passed when computing \'wer\' and \'cer\'.\n        Keywords include \'concatenate_texts\'.\nReturns: depending on the XTREME-S task, one or several of:\n    "accuracy": Accuracy - for \'fleurs-lang_id\', \'minds14\'\n    "f1": F1 score - for \'minds14\'\n    "wer": Word error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    "cer": Character error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    "bleu": BLEU score according to the `sacrebleu` metric - for \'covost2\'\nExamples:\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'mls\')  # \'mls\', \'voxpopuli\', \'fleurs-asr\' or \'babel\'\n    >>> references = ["it is sunny here", "paper and pen are essentials"]\n    >>> predictions = ["it\'s sunny", "paper pen are essential"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'wer\': 0.56, \'cer\': 0.27}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'covost2\')\n    >>> references = ["bonjour paris", "il est necessaire de faire du sport de temps en temp"]\n    >>> predictions = ["bonjour paris", "il est important de faire du sport souvent"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'bleu\': 31.65}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'fleurs-lang_id\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'accuracy\': 0.6}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'minds14\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'f1\': 0.58, \'accuracy\': 0.6}\n'

_a			:	Dict								=  ['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
_a			:	Dict								=  ''

try:
  from jiwer import transforms as tr

  _a			:	Optional[Any]								=  True
except ImportError:
  _a			:	List[Any]								=  False

if _jiwer_available and version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'):



  class     lowercase_		(						tr.AbstractTransform	):

    '''simple docstring'''





    def __init__(       self				,	a_ = " "       )							->			str:


      """simple docstring"""
      UpperCAmelCase  							=		sentence_delimiter
    def   snake_case_     (       self				,	a_       )							->			Optional[int]:


      """simple docstring"""
      return list(a_       )





    def   snake_case_     (       self				,	a_       )							->			List[str]:


      """simple docstring"""
      UpperCAmelCase  							=		[]
      for sent_idx, sentence in enumerate(a_       ):
        chars.extend(self.process_string(a_       )       )
        if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(a_       ) - 1:
          chars.append(self.sentence_delimiter       )
      return chars




  _a			:	List[Any]								=  tr.Compose(
      [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
  )
elif _jiwer_available:
  _a			:	int								=  tr.Compose(
      [
          tr.RemoveMultipleSpaces(),
          tr.Strip(),
          tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
          tr.ReduceToListOfListOfChars(),
      ]
  )
else:
  _a			:	Optional[int]								=  None


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				List[str]    ,				SCREAMING_SNAKE_CASE :				Union[str, Any]  ):
  return float((preds == labels).mean()  )


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				int    ,				SCREAMING_SNAKE_CASE :				Optional[Any]  ):
  return {
      "f1": float(fa_score(y_true=SCREAMING_SNAKE_CASE    ,				y_pred=SCREAMING_SNAKE_CASE    ,				average='macro'  )  ),
      "accuracy": simple_accuracy(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  ),
  }


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				Optional[int]    ,				SCREAMING_SNAKE_CASE :				int    ,				SCREAMING_SNAKE_CASE :				str="exp"    ,				SCREAMING_SNAKE_CASE :				Union[str, Any]=None    ,				SCREAMING_SNAKE_CASE :				Any=False    ,				SCREAMING_SNAKE_CASE :				Optional[Any]=False    ,				SCREAMING_SNAKE_CASE :				Optional[int]=None    ,				SCREAMING_SNAKE_CASE :				List[Any]=False    ,				):
  # xtreme-s can only have one label
  UpperCAmelCase  							=		[[label] for label in labels]
  UpperCAmelCase  							=		list(SCREAMING_SNAKE_CASE  )
  try:
    import sacrebleu as scb
  except ImportError:
    raise ValueError(
        'sacrebleu has to be installed in order to apply the bleu metric for covost2.'
        'You can install it via `pip install sacrebleu`.'  )

  if version.parse(scb.__version__  ) < version.parse('1.4.12'  ):
    raise ImportWarning(
        'To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n'
        'You can install it with `pip install "sacrebleu>=1.4.12"`.'  )

  UpperCAmelCase  							=		len(labels[0]  )
  if any(len(SCREAMING_SNAKE_CASE  ) != references_per_prediction for refs in labels  ):
    raise ValueError('Sacrebleu requires the same number of references for each prediction'  )
  UpperCAmelCase  							=		[[refs[i] for refs in labels] for i in range(SCREAMING_SNAKE_CASE  )]
  UpperCAmelCase  							=		scb.corpus_bleu(
      SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				smooth_method=SCREAMING_SNAKE_CASE    ,				smooth_value=SCREAMING_SNAKE_CASE    ,				force=SCREAMING_SNAKE_CASE    ,				lowercase=SCREAMING_SNAKE_CASE    ,				use_effective_order=SCREAMING_SNAKE_CASE    ,				**({'tokenize': tokenize} if tokenize else {})    ,				)
  return {"bleu": output.score}


def  lowerCamelCase__						(  SCREAMING_SNAKE_CASE :				List[str]    ,				SCREAMING_SNAKE_CASE :				Tuple    ,				SCREAMING_SNAKE_CASE :				Optional[Any]    ,				SCREAMING_SNAKE_CASE :				Optional[int]  ):
  try:
    from jiwer import compute_measures
  except ImportError:
    raise ValueError(
        f'''jiwer has to be installed in order to apply the wer metric for {config_name}.'''
        'You can install it via `pip install jiwer`.'  )

  if concatenate_texts:
    UpperCAmelCase  							=		compute_measures(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )['wer']

    UpperCAmelCase  							=		compute_measures(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				truth_transform=SCREAMING_SNAKE_CASE    ,				hypothesis_transform=SCREAMING_SNAKE_CASE  )['wer']
    return {"wer": wer, "cer": cer}
  else:

    def compute_score(SCREAMING_SNAKE_CASE :				Union[str, Any]    ,				SCREAMING_SNAKE_CASE :				List[Any]    ,				SCREAMING_SNAKE_CASE :				List[str]="wer"  ):
      UpperCAmelCase  							=		0
      UpperCAmelCase  							=		0
      for prediction, reference in zip(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  ):
        if score_type == "wer":
          UpperCAmelCase  							=		compute_measures(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE  )
        elif score_type == "cer":
          UpperCAmelCase  							=		compute_measures(
              SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				truth_transform=SCREAMING_SNAKE_CASE    ,				hypothesis_transform=SCREAMING_SNAKE_CASE  )
        incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
        total += measures["substitutions"] + measures["deletions"] + measures["hits"]
      return incorrect / total

    return {"wer": compute_score(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				'wer'  ), "cer": compute_score(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				'cer'  )}



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

  '''simple docstring'''





  def   snake_case_     (       self       )							->			Tuple:


    """simple docstring"""
    if self.config_name not in _CONFIG_NAMES:
      raise KeyError(F'''You should supply a configuration name selected in {_CONFIG_NAMES}'''       )

    UpperCAmelCase  							=		'int64' if self.config_name in ['fleurs-lang_id', 'minds14'] else 'string'

    return datasets.MetricInfo(
        description=_DESCRIPTION				,	citation=_CITATION				,	inputs_description=_KWARGS_DESCRIPTION				,	features=datasets.Features(
            {'predictions': datasets.Value(a_       ), 'references': datasets.Value(a_       )}       )				,	codebase_urls=[]				,	reference_urls=[]				,	format='numpy'				,	)





  def   snake_case_     (       self				,	a_				,	a_				,	a_=None				,	a_=None       )							->			Dict:


    """simple docstring"""
    UpperCAmelCase  							=		bleu_kwargs if bleu_kwargs is not None else {}
    UpperCAmelCase  							=		wer_kwargs if wer_kwargs is not None else {}

    if self.config_name == "fleurs-lang_id":
      return {"accuracy": simple_accuracy(a_				,	a_       )}
    elif self.config_name == "minds14":
      return fa_and_simple_accuracy(a_				,	a_       )
    elif self.config_name == "covost2":
      UpperCAmelCase  							=		bleu_kwargs.pop('smooth_method'				,	'exp'       )
      UpperCAmelCase  							=		bleu_kwargs.pop('smooth_value'				,	a_       )
      UpperCAmelCase  							=		bleu_kwargs.pop('force'				,	a_       )
      UpperCAmelCase  							=		bleu_kwargs.pop('lowercase'				,	a_       )
      UpperCAmelCase  							=		bleu_kwargs.pop('tokenize'				,	a_       )
      UpperCAmelCase  							=		bleu_kwargs.pop('use_effective_order'				,	a_       )
      return bleu(
          preds=a_				,	labels=a_				,	smooth_method=a_				,	smooth_value=a_				,	force=a_				,	lowercase=a_				,	tokenize=a_				,	use_effective_order=a_				,	)
    elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
      UpperCAmelCase  							=		wer_kwargs.pop('concatenate_texts'				,	a_       )
      return wer_and_cer(a_				,	a_				,	a_				,	self.config_name       )
    else:
      raise KeyError(F'''You should supply a configuration name selected in {_CONFIG_NAMES}'''       )


