




"""simple docstring"""






from typing import List

import jiwer
import jiwer.transforms as tr
from packaging import version

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


UpperCamelCase__    =      ''''''


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




				class 	a__      (							tr.AbstractTransform	):





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




															"""simple docstring"""







															_lowerCAmelCase:Dict						=	sentence_delimiter





										def    __UpperCamelCase  (				self   :						str  ,a__   :						str)    ->							Optional[int]:




															"""simple docstring"""







															return list(__snake_case)







										def    __UpperCamelCase  (				self   :						Tuple  ,a__   :						List[str])    ->							Union[str, Any]:




															"""simple docstring"""







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



				UpperCamelCase__    =      tr.Compose(
				    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
				)
else:
				UpperCamelCase__    =      tr.Compose(
				    [
				        tr.RemoveMultipleSpaces(),
				        tr.Strip(),
				        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
				        tr.ReduceToListOfListOfChars(),
				    ]
				)


UpperCamelCase__    =      '''\
@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.}
}
'''

UpperCamelCase__    =      '''\
Character error rate (CER) is a common metric of the performance of an automatic speech recognition system.

CER is similar to Word Error Rate (WER), but operates on character instead of word. Please refer to docs of WER for further information.

Character error rate can be computed as:

CER = (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 characters,
N is the number of characters in the reference (N=S+D+C).

CER\'s output is not always a number between 0 and 1, in particular when there is a high number of insertions. This value is often associated to the percentage of characters that were incorrectly predicted. The lower the value, the better the
performance of the ASR system with a CER of 0 being a perfect score.
'''

UpperCamelCase__    =      '''
Computes CER score of transcribed segments against references.
Args:
    references: list of references for each speech input.
    predictions: list of transcribtions to score.
    concatenate_texts: Whether or not to concatenate sentences before evaluation, set to True for more accurate result.
Returns:
    (float): the character error rate

Examples:

    >>> predictions = ["this is the prediction", "there is an other sample"]
    >>> references = ["this is the reference", "there is another one"]
    >>> cer = datasets.load_metric("cer")
    >>> cer_score = cer.compute(predictions=predictions, references=references)
    >>> print(cer_score)
    0.34146341463414637
'''




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





						def    __UpperCamelCase  (				self   :						Any)    ->							Dict:




											"""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''',
											        '''https://sites.google.com/site/textdigitisation/qualitymeasures/computingerrorrates''',
											    ]  ,)







						def    __UpperCamelCase  (				self   :						Optional[Any]  ,a__   :						Optional[Any]  ,a__   :						List[str]  ,a__   :						Tuple=False)    ->							List[Any]:




											"""simple docstring"""







											if concatenate_texts:
																return jiwer.compute_measures(
																    __snake_case  ,__snake_case  ,truth_transform=__snake_case  ,hypothesis_transform=__snake_case  ,)["wer"]

											_lowerCAmelCase:int						=	0
											_lowerCAmelCase:Dict						=	0
											for prediction, reference in zip(__snake_case  ,__snake_case):
																_lowerCAmelCase:List[Any]						=	jiwer.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













'''simple docstring'''






import numpy as np
from cva import COLOR_BGR2GRAY, cvtColor, imread
from numpy import array, uinta
from PIL import Image

from digital_image_processing import change_contrast as cc
from digital_image_processing import convert_to_negative as cn
from digital_image_processing import sepia as sp
from digital_image_processing.dithering import burkes as bs
from digital_image_processing.edge_detection import canny
from digital_image_processing.filters import convolve as conv
from digital_image_processing.filters import gaussian_filter as gg
from digital_image_processing.filters import local_binary_pattern as lbp
from digital_image_processing.filters import median_filter as med
from digital_image_processing.filters import sobel_filter as sob
from digital_image_processing.resize import resize as rs

A__							:  List[str]    =imread(r'''digital_image_processing/image_data/lena_small.jpg''')
A__							:  Union[str, Any]    =cvtColor(img, COLOR_BGR2GRAY)
def   UpperCamelCase__ (						):





      """simple docstring"""


      _lowerCAmelCase					=				cn.convert_to_negative(lowerCAmelCase    )
      # assert negative_img array for at least one True
      assert negative_img.any()
def   UpperCamelCase__ (						):





      """simple docstring"""


      with Image.open("""digital_image_processing/image_data/lena_small.jpg"""    ) as img:
            # Work around assertion for response
            assert str(cc.change_contrast(lowerCAmelCase				,      1_10    )    ).startswith(
                """<PIL.Image.Image image mode=RGB size=100x100 at"""    )
def   UpperCamelCase__ (						):





      """simple docstring"""


      _lowerCAmelCase					=				canny.gen_gaussian_kernel(9				,      sigma=1.4    )
      # Assert ambiguous array
      assert resp.all()
def   UpperCamelCase__ (						):





      """simple docstring"""


      _lowerCAmelCase					=				imread("""digital_image_processing/image_data/lena_small.jpg"""				,      0    )
      # assert ambiguous array for all == True
      assert canny_img.all()
      _lowerCAmelCase					=				canny.canny(lowerCAmelCase    )
      # assert canny array for at least one True
      assert canny_array.any()
def   UpperCamelCase__ (						):





      """simple docstring"""


      assert gg.gaussian_filter(lowerCAmelCase				,      5				,      sigma=0.9    ).all()
def   UpperCamelCase__ (						):





      """simple docstring"""


      _lowerCAmelCase					=				array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]]    )
      _lowerCAmelCase					=				conv.img_convolve(lowerCAmelCase				,      lowerCAmelCase    ).astype(lowerCAmelCase    )
      assert res.any()
def   UpperCamelCase__ (						):





      """simple docstring"""


      assert med.median_filter(lowerCAmelCase				,      3    ).any()
def   UpperCamelCase__ (						):





      """simple docstring"""


      _lowerCAmelCase	,				_lowerCAmelCase					=				sob.sobel_filter(lowerCAmelCase    )
      assert grad.any() and theta.any()
def   UpperCamelCase__ (						):





      """simple docstring"""


      _lowerCAmelCase					=				sp.make_sepia(lowerCAmelCase				,      20    )
      assert sepia.all()
def   UpperCamelCase__ (						lowerCAmelCase = "digital_image_processing/image_data/lena_small.jpg"    ):





      """simple docstring"""


      _lowerCAmelCase					=				bs.Burkes(imread(lowerCAmelCase				,      1    )				,      1_20    )
      burkes.process()
      assert burkes.output_img.any()
def   UpperCamelCase__ (						lowerCAmelCase = "digital_image_processing/image_data/lena_small.jpg"				,      ):





      """simple docstring"""


      _lowerCAmelCase					=				rs.NearestNeighbour(imread(lowerCAmelCase				,      1    )				,      4_00				,      2_00    )
      nn.process()
      assert nn.output.any()





def   UpperCamelCase__ (						):





      """simple docstring"""


      _lowerCAmelCase					=				"""digital_image_processing/image_data/lena.jpg"""

      # Reading the image and converting it to grayscale.
      _lowerCAmelCase					=				imread(lowerCAmelCase				,      0    )

      # Test for get_neighbors_pixel function() return not None
      _lowerCAmelCase					=				0
      _lowerCAmelCase					=				0
      _lowerCAmelCase					=				image[x_coordinate][y_coordinate]

      _lowerCAmelCase					=				lbp.get_neighbors_pixel(
          lowerCAmelCase				,      lowerCAmelCase				,      lowerCAmelCase				,      lowerCAmelCase    )

      assert neighbors_pixels is not None

      # Test for local_binary_pattern function()
      # Create a numpy array as the same height and width of read image
      _lowerCAmelCase					=				np.zeros((image.shape[0], image.shape[1])    )

      # Iterating through the image and calculating the local binary pattern value
      # for each pixel.
      for i in range(0				,      image.shape[0]    ):
            for j in range(0				,      image.shape[1]    ):
                  _lowerCAmelCase					=				lbp.local_binary_value(lowerCAmelCase				,      lowerCAmelCase				,      lowerCAmelCase    )

      assert lbp_image.any()






