





from jiwer import compute_measures

import datasets


lowerCAmelCase_						   =    """\
@inproceedings{inproceedings,
    author = {Morris, Andrew and Maier, Viktoria and Green, Phil},
    year = {2004},
    month = {01},
    pages = {},
    title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.}
}
"""

lowerCAmelCase_						   =    """\
Word error rate (WER) is a common metric of the performance of an automatic speech recognition system.

The general difficulty of measuring performance lies in the fact that the recognized word sequence can have a different length from the reference word sequence (supposedly the correct one). The WER is derived from the Levenshtein distance, working at the word level instead of the phoneme level. The WER is a valuable tool for comparing different systems as well as for evaluating improvements within one system. This kind of measurement, however, provides no details on the nature of translation errors and further work is therefore required to identify the main source(s) of error and to focus any research effort.

This problem is solved by first aligning the recognized word sequence with the reference (spoken) word sequence using dynamic string alignment. Examination of this issue is seen through a theory called the power law that states the correlation between perplexity and word error rate.

Word error rate can then be computed as:

WER = (S + D + I) / N = (S + D + I) / (S + D + C)

where

S is the number of substitutions,
D is the number of deletions,
I is the number of insertions,
C is the number of correct words,
N is the number of words in the reference (N=S+D+C).

This value indicates the average number of errors per reference word. The lower the value, the better the
performance of the ASR system with a WER of 0 being a perfect score.
"""

lowerCAmelCase_						   =    """
Compute WER score of transcribed segments against references.

Args:
    references: List of references for each speech input.
    predictions: List of transcriptions to score.
    concatenate_texts (bool, default=False): Whether to concatenate all input texts or compute WER iteratively.

Returns:
    (float): the word error rate

Examples:

    >>> predictions = [\"this is the prediction\", \"there is an other sample\"]
    >>> references = [\"this is the reference\", \"there is another one\"]
    >>> wer = datasets.load_metric(\"wer\")
    >>> wer_score = wer.compute(predictions=predictions, references=references)
    >>> print(wer_score)
    0.5
"""



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,    _KWARGS_DESCRIPTION							)
class        _lowerCAmelCase    (			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'      ,				id='sequence'							),
                'references': datasets.Value('string'      ,				id='sequence'							),
            }							)      ,				codebase_urls=['https://github.com/jitsi/jiwer/']      ,				reference_urls=[
            'https://en.wikipedia.org/wiki/Word_error_rate',
        ]      ,				)







  def UpperCamelCase_ (      self      :					Dict      ,				UpperCamelCase      :					Union[str, Any]=None      ,				UpperCamelCase      :					Tuple=None      ,				UpperCamelCase      :					Optional[Any]=False							):


    '''simple docstring'''





    if concatenate_texts:
      return compute_measures(UpperCamelCase      ,				UpperCamelCase							)["wer"]
    else:
      _snake_case   :				Dict														=	0
      _snake_case   :				List[str]														=	0
      for prediction, reference in zip(UpperCamelCase      ,				UpperCamelCase							):
        _snake_case   :				str														=	compute_measures(UpperCamelCase      ,				UpperCamelCase							)
        incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
        total += measures["substitutions"] + measures["deletions"] + measures["hits"]
      return incorrect / total











import math
import random
from typing import Any

from .hill_climbing import SearchProblem


def     lowerCamelCase_	(      lowerCAmelCase:	Tuple    ,							lowerCAmelCase:	bool = True    ,							lowerCAmelCase:	float = math.inf    ,							lowerCAmelCase:	float = -math.inf    ,							lowerCAmelCase:	float = math.inf    ,							lowerCAmelCase:	float = -math.inf    ,							lowerCAmelCase:	bool = False    ,							lowerCAmelCase:	float = 1_00    ,							lowerCAmelCase:	float = 0.0_1    ,							lowerCAmelCase:	float = 1    ,							)->		Any:
  _snake_case   :				int														=	False
  _snake_case   :				Any														=	search_prob
  _snake_case   :				Tuple														=	start_temperate
  _snake_case   :				Any														=	[]
  _snake_case   :				List[str]														=	0
  _snake_case   :				Optional[Any]														=	None

  while not search_end:
    _snake_case   :				List[Any]														=	current_state.score()
    if best_state is None or current_score > best_state.score():
      _snake_case   :				Dict														=	current_state
    scores.append(lowerCAmelCase				)
    iterations += 1
    _snake_case   :				Optional[int]														=	None
    _snake_case   :				Union[str, Any]														=	current_state.get_neighbors()
    while (
        next_state is None and neighbors
    ):  # till we do not find a neighbor that we can move to
      _snake_case   :				Dict														=	random.randint(0    ,							len(lowerCAmelCase				) - 1				)  # picking a random neighbor
      _snake_case   :				int														=	neighbors.pop(lowerCAmelCase				)
      _snake_case   :				Union[str, Any]														=	picked_neighbor.score() - current_score

      if (
          picked_neighbor.x > max_x
          or picked_neighbor.x < min_x
          or picked_neighbor.y > max_y
          or picked_neighbor.y < min_y
      ):
        continue  # neighbor outside our bounds

      if not find_max:
        _snake_case   :				Union[str, Any]														=	change * -1  # in case we are finding minimum
      if change > 0:  # improves the solution
        _snake_case   :				Union[str, Any]														=	picked_neighbor
      else:
        _snake_case   :				Optional[Any]														=	(math.e) ** (
            change / current_temp
        )  # probability generation function
        if random.random() < probability:  # random number within probability
          _snake_case   :				int														=	picked_neighbor
    _snake_case   :				List[Any]														=	current_temp - (current_temp * rate_of_decrease)

    if current_temp < threshold_temp or next_state is None:
      # temperature below threshold, or could not find a suitable neighbor
      _snake_case   :				List[str]														=	True
    else:
      _snake_case   :				Union[str, Any]														=	next_state

  if visualization:
    from matplotlib import pyplot as plt

    plt.plot(range(lowerCAmelCase				)    ,							lowerCAmelCase				)
    plt.xlabel('Iterations'				)
    plt.ylabel('Function values'				)
    plt.show()
  return best_state


if __name__ == "__main__":


      def     lowerCamelCase_	(      lowerCAmelCase:	Any    ,							lowerCAmelCase:	List[Any]				)->		List[Any]:
        return (x**2) + (y**2)

      # starting the problem with initial coordinates (12, 47)
      lowerCAmelCase_						   =    SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa)
      lowerCAmelCase_						   =    simulated_annealing(
          prob, find_max=False, max_x=100, min_x=5, max_y=50, min_y=-5, visualization=True
      )
      print(
          """The minimum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 """
          F"""and 50 > y > - 5 found via hill climbing: {local_min.score()}"""
      )

      # starting the problem with initial coordinates (12, 47)
      lowerCAmelCase_						   =    SearchProblem(x=12, y=47, step_size=1, function_to_optimize=test_fa)
      lowerCAmelCase_						   =    simulated_annealing(
          prob, find_max=True, max_x=100, min_x=5, max_y=50, min_y=-5, visualization=True
      )
      print(
          """The maximum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 """
          F"""and 50 > y > - 5 found via hill climbing: {local_min.score()}"""
      )


      def     lowerCamelCase_	(      lowerCAmelCase:	Any    ,							lowerCAmelCase:	Dict				)->		Dict:
        return (3 * x**2) - (6 * y)

      lowerCAmelCase_						   =    SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
      lowerCAmelCase_						   =    simulated_annealing(prob, find_max=False, visualization=True)
      print(
          """The minimum score for f(x, y) = 3*x^2 - 6*y found via hill climbing: """
          F"""{local_min.score()}"""
      )

      lowerCAmelCase_						   =    SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
      lowerCAmelCase_						   =    simulated_annealing(prob, find_max=True, visualization=True)







      print(
          """The maximum score for f(x, y) = 3*x^2 - 6*y found via hill climbing: """
          F"""{local_min.score()}"""
      )




