code: 
  
  
  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)
  __lowerCamelCase       :       str				   =			"\\n"
  
  __lowerCamelCase       :       Union[str, 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"
  
  __lowerCamelCase       :       Tuple				   =			"\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"
  
  __lowerCamelCase       :       List[str]				   =			["fleurs-asr", "mls", "voxpopuli", "babel", "covost2", "fleurs-lang_id", "minds14"]
  __lowerCamelCase       :       List[Any]				   =			""
  
  try:
  						from jiwer import transforms as tr
  
  						__lowerCamelCase       :       Tuple				   =			True
  except ImportError:
  						__lowerCamelCase       :       int				   =			False
  
  if _jiwer_available and version.parse(importlib_metadata.version("jiwer")) < version.parse("2.3.0"):
  
  
  
  						class 			a      (      tr.AbstractTransform   ):
  
  
  
  
  
  
  								def __init__(  self	,     __UpperCamelCase = " "							)->			List[Any]:
  												'''simple docstring'''
  
  
  												A__     :							Union[str, Any]   				=sentence_delimiter
  
  
  
  
  
  
  								def       lowerCAmelCase_  (  self	,     __UpperCamelCase							)->			Optional[int]:
  												'''simple docstring'''
  
  
  												return list(__UpperCamelCase							)
  
  
  
  
  
  
  								def       lowerCAmelCase_  (  self	,     __UpperCamelCase							)->			int:
  												'''simple docstring'''
  
  
  												A__     :							str   				=[]
  												for sent_idx, sentence in enumerate(__UpperCamelCase							):
  																chars.extend(self.process_string(__UpperCamelCase							)							)
  																if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(__UpperCamelCase							) - 1:
  																				chars.append(self.sentence_delimiter							)
  												return chars
  
  
  
  
  
  
  
  						__lowerCamelCase       :       Optional[int]				   =			tr.Compose(
  						    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
  						)
  elif _jiwer_available:
  						__lowerCamelCase       :       Dict				   =			tr.Compose(
  						    [
  						        tr.RemoveMultipleSpaces(),
  						        tr.Strip(),
  						        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
  						        tr.ReduceToListOfListOfChars(),
  						    ]
  						)
  else:
  						__lowerCamelCase       :       Union[str, Any]				   =			None
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_,	snake_case_	)			->							int:
  				return float((preds == labels).mean()	)
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_,	snake_case_	)			->							Tuple:
  				return {
  				    "f1": float(fa_score(y_true=snake_case_,	y_pred=snake_case_,	average='''macro'''	)	),
  				    "accuracy": simple_accuracy(snake_case_,	snake_case_	),
  				}
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_,	snake_case_,	snake_case_="exp",	snake_case_=None,	snake_case_=False,	snake_case_=False,	snake_case_=None,	snake_case_=False,	)			->							Optional[Any]:
  				# xtreme-s can only have one label
  				A__     :							str   				=[[label] for label in labels]
  				A__     :							List[Any]   				=list(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"`.'''	)
  
  				A__     :							List[str]   				=len(labels[0]	)
  				if any(len(snake_case_	) != references_per_prediction for refs in labels	):
  								raise ValueError('''Sacrebleu requires the same number of references for each prediction'''	)
  				A__     :							int   				=[[refs[i] for refs in labels] for i in range(snake_case_	)]
  				A__     :							Any   				=scb.corpus_bleu(
  				    snake_case_,	snake_case_,	smooth_method=snake_case_,	smooth_value=snake_case_,	force=snake_case_,	lowercase=snake_case_,	use_effective_order=snake_case_,	**({'''tokenize''': tokenize} if tokenize else {}),	)
  				return {"bleu": output.score}
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_,	snake_case_,	snake_case_,	snake_case_	)			->							List[Any]:
  				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:
  								A__     :							str   				=compute_measures(snake_case_,	snake_case_	)['''wer''']
  
  								A__     :							int   				=compute_measures(snake_case_,	snake_case_,	truth_transform=snake_case_,	hypothesis_transform=snake_case_	)['''wer''']
  								return {"wer": wer, "cer": cer}
  				else:
  
  								def compute_score(snake_case_,	snake_case_,	snake_case_="wer"	):
  												A__     :							Dict   				=0
  												A__     :							Tuple   				=0
  												for prediction, reference in zip(snake_case_,	snake_case_	):
  																if score_type == "wer":
  																				A__     :							Optional[int]   				=compute_measures(snake_case_,	snake_case_	)
  																elif score_type == "cer":
  																				A__     :							str   				=compute_measures(
  																				    snake_case_,	snake_case_,	truth_transform=snake_case_,	hypothesis_transform=snake_case_	)
  																incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
  																total += measures["substitutions"] + measures["deletions"] + measures["hits"]
  												return incorrect / total
  
  								return {"wer": compute_score(snake_case_,	snake_case_,	'''wer'''	), "cer": compute_score(snake_case_,	snake_case_,	'''cer'''	)}
  
  
  
  
  @datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION      ,_KWARGS_DESCRIPTION   )
  class 			a      (      datasets.Metric   ):
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  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}'							)
  
  						A__     :							Any   				='''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(__UpperCamelCase							), '''references''': datasets.Value(__UpperCamelCase							)}							)	,     codebase_urls=[]	,     reference_urls=[]	,     format='''numpy'''	,     )
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase=None	,     __UpperCamelCase=None							)->			List[str]:
  						'''simple docstring'''
  
  
  						A__     :							int   				=bleu_kwargs if bleu_kwargs is not None else {}
  						A__     :							Optional[int]   				=wer_kwargs if wer_kwargs is not None else {}
  
  						if self.config_name == "fleurs-lang_id":
  										return {"accuracy": simple_accuracy(__UpperCamelCase	,     __UpperCamelCase							)}
  						elif self.config_name == "minds14":
  										return fa_and_simple_accuracy(__UpperCamelCase	,     __UpperCamelCase							)
  						elif self.config_name == "covost2":
  										A__     :							List[Any]   				=bleu_kwargs.pop('''smooth_method'''	,     '''exp'''							)
  										A__     :							Union[str, Any]   				=bleu_kwargs.pop('''smooth_value'''	,     __UpperCamelCase							)
  										A__     :							int   				=bleu_kwargs.pop('''force'''	,     __UpperCamelCase							)
  										A__     :							List[str]   				=bleu_kwargs.pop('''lowercase'''	,     __UpperCamelCase							)
  										A__     :							Union[str, Any]   				=bleu_kwargs.pop('''tokenize'''	,     __UpperCamelCase							)
  										A__     :							int   				=bleu_kwargs.pop('''use_effective_order'''	,     __UpperCamelCase							)
  										return bleu(
  										    preds=__UpperCamelCase	,     labels=__UpperCamelCase	,     smooth_method=__UpperCamelCase	,     smooth_value=__UpperCamelCase	,     force=__UpperCamelCase	,     lowercase=__UpperCamelCase	,     tokenize=__UpperCamelCase	,     use_effective_order=__UpperCamelCase	,     )
  						elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
  										A__     :							Union[str, Any]   				=wer_kwargs.pop('''concatenate_texts'''	,     __UpperCamelCase							)
  										return wer_and_cer(__UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase	,     self.config_name							)
  						else:
  										raise KeyError(F'You should supply a configuration name selected in {_CONFIG_NAMES}'							)
  
  
  
  
style_context: 
  
  
  import argparse
  import collections
  from pathlib import Path
  
  import torch
  from torch.serialization import default_restore_location
  
  from transformers import BertConfig, DPRConfig, DPRContextEncoder, DPRQuestionEncoder, DPRReader
  
  
  __lowerCamelCase       :       Optional[Any]				   =			collections.namedtuple(
      "CheckpointState", ["model_dict", "optimizer_dict", "scheduler_dict", "offset", "epoch", "encoder_params"]
  )
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							CheckpointState:
  				print(f'Reading saved model from {model_file}'	)
  				A__     :							Optional[int]   				=torch.load(snake_case_,	map_location=lambda snake_case_,	snake_case_	: default_restore_location(snake_case_,	'''cpu'''	)	)
  				return CheckpointState(**snake_case_	)
  
  
  
  class 			a      :
  
  
  
  
  
  
  		def __init__(  self	,     __UpperCamelCase							)->			Union[str, Any]:
  						'''simple docstring'''
  
  
  						A__     :							Dict   				=src_file
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Optional[Any]:
  						'''simple docstring'''
  
  
  						raise NotImplementedError
  
  
  
  
  
  
  		@staticmethod
  		def       lowerCAmelCase_  (  __UpperCamelCase	,     *__UpperCamelCase	,     **__UpperCamelCase							)->			"DPRState":
  						'''simple docstring'''
  
  
  						if comp_type.startswith('''c'''							):
  										return DPRContextEncoderState(*__UpperCamelCase	,     **__UpperCamelCase							)
  						if comp_type.startswith('''q'''							):
  										return DPRQuestionEncoderState(*__UpperCamelCase	,     **__UpperCamelCase							)
  						if comp_type.startswith('''r'''							):
  										return DPRReaderState(*__UpperCamelCase	,     **__UpperCamelCase							)
  						else:
  										raise ValueError('''Component type must be either \'ctx_encoder\', \'question_encoder\' or \'reader\'.'''							)
  
  
  
  
  
  
  
  class 			a      (      UpperCamelCase_   ):
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Optional[Any]:
  						'''simple docstring'''
  
  
  						A__     :							Optional[int]   				=DPRContextEncoder(DPRConfig(**BertConfig.get_config_dict('''bert-base-uncased'''							)[0]							)							)
  						print(F'Loading DPR biencoder from {self.src_file}'							)
  						A__     :							Optional[int]   				=load_states_from_checkpoint(self.src_file							)
  						A__				,  A__     :							List[str]   				=model.ctx_encoder, '''ctx_model.'''
  						# Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
  						A__     :							Optional[int]   				={'''bert_model.embeddings.position_ids''': model.ctx_encoder.bert_model.embeddings.position_ids}
  						for key, value in saved_state.model_dict.items():
  										if key.startswith(__UpperCamelCase							):
  														A__     :							int   				=key[len(__UpperCamelCase							) :]
  														if not key.startswith('''encode_proj.'''							):
  																		A__     :							Any   				='''bert_model.''' + key
  														A__     :							List[str]   				=value
  						encoder.load_state_dict(__UpperCamelCase							)
  						return model
  
  
  
  
  
  
  
  class 			a      (      UpperCamelCase_   ):
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Dict:
  						'''simple docstring'''
  
  
  						A__     :							Union[str, Any]   				=DPRQuestionEncoder(DPRConfig(**BertConfig.get_config_dict('''bert-base-uncased'''							)[0]							)							)
  						print(F'Loading DPR biencoder from {self.src_file}'							)
  						A__     :							List[str]   				=load_states_from_checkpoint(self.src_file							)
  						A__				,  A__     :							Optional[int]   				=model.question_encoder, '''question_model.'''
  						# Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
  						A__     :							Optional[Any]   				={'''bert_model.embeddings.position_ids''': model.question_encoder.bert_model.embeddings.position_ids}
  						for key, value in saved_state.model_dict.items():
  										if key.startswith(__UpperCamelCase							):
  														A__     :							List[Any]   				=key[len(__UpperCamelCase							) :]
  														if not key.startswith('''encode_proj.'''							):
  																		A__     :							Tuple   				='''bert_model.''' + key
  														A__     :							str   				=value
  						encoder.load_state_dict(__UpperCamelCase							)
  						return model
  
  
  
  
  
  
  
  class 			a      (      UpperCamelCase_   ):
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			int:
  						'''simple docstring'''
  
  
  						A__     :							Optional[int]   				=DPRReader(DPRConfig(**BertConfig.get_config_dict('''bert-base-uncased'''							)[0]							)							)
  						print(F'Loading DPR reader from {self.src_file}'							)
  						A__     :							Dict   				=load_states_from_checkpoint(self.src_file							)
  						# Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
  						A__     :							Optional[Any]   				={
  						    '''encoder.bert_model.embeddings.position_ids''': model.span_predictor.encoder.bert_model.embeddings.position_ids
  						}
  						for key, value in saved_state.model_dict.items():
  										if key.startswith('''encoder.'''							) and not key.startswith('''encoder.encode_proj'''							):
  														A__     :							List[Any]   				='''encoder.bert_model.''' + key[len('''encoder.'''							) :]
  										A__     :							Optional[int]   				=value
  						model.span_predictor.load_state_dict(__UpperCamelCase							)
  						return model
  
  
  
  
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_,	snake_case_,	snake_case_	)			->							Optional[int]:
  				A__     :							Optional[int]   				=Path(snake_case_	)
  				dest_dir.mkdir(exist_ok=snake_case_	)
  
  				A__     :							Tuple   				=DPRState.from_type(snake_case_,	src_file=snake_case_	)
  				A__     :							str   				=dpr_state.load_dpr_model()
  				model.save_pretrained(snake_case_	)
  				model.from_pretrained(snake_case_	)  # sanity check
  
  
  if __name__ == "__main__":
  						__lowerCamelCase       :       Optional[Any]				   =			argparse.ArgumentParser()
  						# Required parameters
  						parser.add_argument(
  						    "--type", type=str, help="Type of the component to convert: 'ctx_encoder', 'question_encoder' or 'reader'."
  						)
  						parser.add_argument(
  						    "--src",
  						    type=str,
  						    help=(
  						        "Path to the dpr checkpoint file. They can be downloaded from the official DPR repo"
  						        " https://github.com/facebookresearch/DPR. Note that in the official repo, both encoders are stored in the"
  						        " 'retriever' checkpoints."
  						    ),
  						)
  						parser.add_argument("--dest", type=str, default=None, help="Path to the output PyTorch model directory.")
  						__lowerCamelCase       :       Tuple				   =			parser.parse_args()
  
  						__lowerCamelCase       :       Optional[Any]				   =			Path(args.src)
  						__lowerCamelCase       :       Optional[int]				   =			F"converted-{src_file.name}" if args.dest is None else args.dest
  						__lowerCamelCase       :       Optional[Any]				   =			Path(dest_dir)
  						assert src_file.exists()
  						assert (
  						    args.type is not None
  						), "Please specify the component type of the DPR model to convert: 'ctx_encoder', 'question_encoder' or 'reader'."
  						convert(args.type, src_file, dest_dir)
  
  
  
  