Upload 34 files

decoding.py

@@ -0,0 +1,1006 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple, Iterable, Optional, Sequence, Union, TYPE_CHECKING
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+from torch.distributions import Categorical
+
+from .audio import CHUNK_LENGTH
+from .tokenizer import Tokenizer, get_tokenizer
+from .utils import compression_ratio
+
+if TYPE_CHECKING:
+    from .model import Whisper
+
+
+@torch.no_grad()
+def detect_language(model: "Whisper", mel: Tensor, tokenizer: Tokenizer = None) -> Tuple[Tensor, List[dict]]:
+    """
+    Detect the spoken language in the audio, and return them as list of strings, along with the ids
+    of the most probable language tokens and the probability distribution over all language tokens.
+    This is performed outside the main decode loop in order to not interfere with kv-caching.
+
+    Returns
+    -------
+    language_tokens : Tensor, shape = (n_audio,)
+        ids of the most probable language tokens, which appears after the startoftranscript token.
+    language_probs : List[Dict[str, float]], length = n_audio
+        list of dictionaries containing the probability distribution over all languages.
+    """
+    if tokenizer is None:
+        tokenizer = get_tokenizer(model.is_multilingual)
+    if tokenizer.language is None or tokenizer.language_token not in tokenizer.sot_sequence:
+        raise ValueError(f"This model doesn't have language tokens so it can't perform lang id")
+
+    single = mel.ndim == 2
+    if single:
+        mel = mel.unsqueeze(0)
+
+    # skip encoder forward pass if already-encoded audio features were given
+    if mel.shape[-2:] != (model.dims.n_audio_ctx, model.dims.n_audio_state):
+        mel = model.encoder(mel)
+
+    # forward pass using a single token, startoftranscript
+    n_audio = mel.shape[0]
+    x = torch.tensor([[tokenizer.sot]] * n_audio).to(mel.device)  # [n_audio, 1]
+    logits = model.logits(x, mel)[:, 0]
+
+    # collect detected languages; suppress all non-language tokens
+    mask = torch.ones(logits.shape[-1], dtype=torch.bool)
+    mask[list(tokenizer.all_language_tokens)] = False
+    logits[:, mask] = -np.inf
+    language_tokens = logits.argmax(dim=-1)
+    language_token_probs = logits.softmax(dim=-1).cpu()
+    language_probs = [
+        {
+            c: language_token_probs[i, j].item()
+            for j, c in zip(tokenizer.all_language_tokens, tokenizer.all_language_codes)
+        }
+        for i in range(n_audio)
+    ]
+
+    if single:
+        language_tokens = language_tokens[0]
+        language_probs = language_probs[0]
+
+    return language_tokens, language_probs
+
+
+@dataclass(frozen=True)
+class DecodingOptions:
+    task: str = "transcribe"  # whether to perform X->X "transcribe" or X->English "translate"
+    language: Optional[str] = None  # language that the audio is in; uses detected language if None
+
+    # sampling-related options
+    temperature: float = 0.0
+    sample_len: Optional[int] = None  # maximum number of tokens to sample
+    best_of: Optional[int] = None     # number of independent samples to collect, when t > 0
+    beam_size: Optional[int] = None   # number of beams in beam search, when t == 0
+    patience: Optional[float] = None  # patience in beam search (https://arxiv.org/abs/2204.05424)
+
+    # options for ranking generations (either beams or best-of-N samples)
+    length_penalty: Optional[float] = None   # "alpha" in Google NMT, None defaults to length norm
+
+    # prompt, prefix, and token suppression
+    prompt: Optional[Union[str, List[int]]] = None   # text or tokens for the previous context
+    prefix: Optional[Union[str, List[int]]] = None   # text or tokens to prefix the current context
+    suppress_blank: bool = True                      # this will suppress blank outputs
+
+    # list of tokens ids (or comma-separated token ids) to suppress
+    # "-1" will suppress a set of symbols as defined in `tokenizer.non_speech_tokens()`
+    suppress_tokens: Optional[Union[str, Iterable[int]]] = "-1"
+
+    # timestamp sampling options
+    without_timestamps: bool = False              # use <|notimestamps|> to sample text tokens only
+    max_initial_timestamp: Optional[float] = 1.0  # the initial timestamp cannot be later than this
+
+    # implementation details
+    fp16: bool = True  # use fp16 for most of the calculation
+
+
+@dataclass(frozen=True)
+class DecodingResult:
+    audio_features: Tensor
+    language: str
+    language_probs: Optional[Dict[str, float]] = None
+    tokens: List[int] = field(default_factory=list)
+    text: str = ""
+    avg_logprob: float = np.nan
+    no_speech_prob: float = np.nan
+    temperature: float = np.nan
+    compression_ratio: float = np.nan
+
+
+class Inference:
+    def logits(self, tokens: Tensor, audio_features: Tensor) -> Tensor:
+        """Perform a forward pass on the decoder and return per-token logits"""
+        raise NotImplementedError
+
+    def rearrange_kv_cache(self, source_indices) -> None:
+        """Update the key-value cache according to the updated beams"""
+        raise NotImplementedError
+
+    def cleanup_caching(self) -> None:
+        """Clean up any resources or hooks after decoding is finished"""
+        pass
+
+
+class PyTorchInference(Inference):
+    def __init__(self, model: "Whisper", initial_token_length: int):
+        self.model: "Whisper" = model
+        self.initial_token_length = initial_token_length
+        self.kv_cache = {}
+        self.hooks = []
+
+    def logits(self, tokens: Tensor, audio_features: Tensor) -> Tensor:
+        if not self.kv_cache:
+            self.kv_cache, self.hooks = self.model.install_kv_cache_hooks()
+
+        if tokens.shape[-1] > self.initial_token_length:
+            # only need to use the last token except in the first forward pass
+            tokens = tokens[:, -1:]
+
+        return self.model.decoder(tokens, audio_features, kv_cache=self.kv_cache)
+
+    def cleanup_caching(self):
+        for hook in self.hooks:
+            hook.remove()
+
+        self.kv_cache = {}
+        self.hooks = []
+
+    def rearrange_kv_cache(self, source_indices):
+        for module, tensor in self.kv_cache.items():
+            # update the key/value cache to contain the selected sequences
+            self.kv_cache[module] = tensor[source_indices].detach()
+
+
+class SequenceRanker:
+    def rank(self, tokens: List[List[Tensor]], sum_logprobs: List[List[float]]) -> List[int]:
+        """
+        Given a list of groups of samples and their cumulative log probabilities,
+        return the indices of the samples in each group to select as the final result
+        """
+        raise NotImplementedError
+
+
+class MaximumLikelihoodRanker(SequenceRanker):
+    """
+    Select the sample with the highest log probabilities, penalized using either
+    a simple length normalization or Google NMT paper's length penalty
+    """
+
+    def __init__(self, length_penalty: Optional[float]):
+        self.length_penalty = length_penalty
+
+    def rank(self, tokens: List[List[Tensor]], sum_logprobs: List[List[float]]):
+        def scores(logprobs, lengths):
+            result = []
+            for logprob, length in zip(logprobs, lengths):
+                if self.length_penalty is None:
+                    penalty = length
+                else:
+                    # from the Google NMT paper
+                    penalty = ((5 + length) / 6) ** self.length_penalty
+                result.append(logprob / penalty)
+            return result
+
+        # get the sequence with the highest score
+        lengths = [[len(t) for t in s] for s in tokens]
+        return [np.argmax(scores(p, l)) for p, l in zip(sum_logprobs, lengths)]
+
+
+class TokenDecoder:
+    def reset(self):
+        """Initialize any stateful variables for decoding a new sequence"""
+
+    def update(self, tokens: Tensor, logits: Tensor, sum_logprobs: Tensor) -> Tuple[Tensor, bool]:
+        """Specify how to select the next token, based on the current trace and logits
+
+        Parameters
+        ----------
+        tokens : Tensor, shape = (n_batch, current_sequence_length)
+            all tokens in the context so far, including the prefix and sot_sequence tokens
+
+        logits : Tensor, shape = (n_batch, vocab_size)
+            per-token logits of the probability distribution at the current step
+
+        sum_logprobs : Tensor, shape = (n_batch)
+            cumulative log probabilities for each sequence
+
+        Returns
+        -------
+        tokens : Tensor, shape = (n_batch, current_sequence_length + 1)
+            the tokens, appended with the selected next token
+
+        completed : bool
+            True if all sequences has reached the end of text
+
+        """
+        raise NotImplementedError
+
+    def finalize(
+        self, tokens: Tensor, sum_logprobs: Tensor
+    ) -> Tuple[Sequence[Sequence[Tensor]], List[List[float]]]:
+        """Finalize search and return the final candidate sequences
+
+        Parameters
+        ----------
+        tokens : Tensor, shape = (n_audio, n_group, current_sequence_length)
+            all tokens in the context so far, including the prefix and sot_sequence
+
+        sum_logprobs : Tensor, shape = (n_audio, n_group)
+            cumulative log probabilities for each sequence
+
+        Returns
+        -------
+        tokens : Sequence[Sequence[Tensor]], length = n_audio
+            sequence of Tensors containing candidate token sequences, for each audio input
+
+        sum_logprobs : List[List[float]], length = n_audio
+            sequence of cumulative log probabilities corresponding to the above
+
+        """
+        raise NotImplementedError
+
+
+class GreedyDecoder(TokenDecoder):
+    def __init__(self, temperature: float, eot: int):
+        self.temperature = temperature
+        self.eot = eot
+
+    def update(self, tokens: Tensor, logits: Tensor, sum_logprobs: Tensor) -> Tuple[Tensor, bool]:
+        temperature = self.temperature
+        if temperature == 0:
+            next_tokens = logits.argmax(dim=-1)
+        else:
+            next_tokens = Categorical(logits=logits / temperature).sample()
+
+        logprobs = F.log_softmax(logits.float(), dim=-1)
+        current_logprobs = logprobs[torch.arange(logprobs.shape[0]), next_tokens]
+        sum_logprobs += current_logprobs * (tokens[:, -1] != self.eot)
+
+        next_tokens[tokens[:, -1] == self.eot] = self.eot
+        tokens = torch.cat([tokens, next_tokens[:, None]], dim=-1)
+
+        completed = (tokens[:, -1] == self.eot).all()
+        return tokens, completed
+
+    def finalize(self, tokens: Tensor, sum_logprobs: Tensor):
+        # make sure each sequence has at least one EOT token at the end
+        tokens = F.pad(tokens, (0, 1), value=self.eot)
+        return tokens, sum_logprobs.tolist()
+
+
+class BeamSearchDecoder(TokenDecoder):
+    def __init__(self, beam_size: int, eot: int, inference: Inference, patience: Optional[float] = None):
+        self.beam_size = beam_size
+        self.eot = eot
+        self.inference = inference
+        self.patience = patience or 1.0
+        self.max_candidates: int = round(beam_size * self.patience)
+        self.finished_sequences = None
+
+        assert self.max_candidates > 0, f"Invalid beam size ({beam_size}) or patience ({patience})"
+
+    def reset(self):
+        self.finished_sequences = None
+
+    def update(self, tokens: Tensor, logits: Tensor, sum_logprobs: Tensor) -> Tuple[Tensor, bool]:
+        if tokens.shape[0] % self.beam_size != 0:
+            raise ValueError(f"{tokens.shape}[0] % {self.beam_size} != 0")
+
+        n_audio = tokens.shape[0] // self.beam_size
+        if self.finished_sequences is None:  # for the first update
+            self.finished_sequences = [{} for _ in range(n_audio)]
+
+        logprobs = F.log_softmax(logits.float(), dim=-1)
+        next_tokens, source_indices, finished_sequences = [], [], []
+        for i in range(n_audio):
+            scores, sources, finished = {}, {}, {}
+
+            # STEP 1: calculate the cumulative log probabilities for possible candidates
+            for j in range(self.beam_size):
+                idx = i * self.beam_size + j
+                prefix = tokens[idx].tolist()
+                for logprob, token in zip(*logprobs[idx].topk(self.beam_size + 1)):
+                    new_logprob = (sum_logprobs[idx] + logprob).item()
+                    sequence = tuple(prefix + [token.item()])
+                    scores[sequence] = new_logprob
+                    sources[sequence] = idx
+
+            # STEP 2: rank the candidates and keep the top beam_size sequences for each audio
+            saved = 0
+            for sequence in sorted(scores, key=scores.get, reverse=True):
+                if sequence[-1] == self.eot:
+                    finished[sequence] = scores[sequence]
+                else:
+                    sum_logprobs[len(next_tokens)] = scores[sequence]
+                    next_tokens.append(sequence)
+                    source_indices.append(sources[sequence])
+
+                    saved += 1
+                    if saved == self.beam_size:
+                        break
+
+            finished_sequences.append(finished)
+
+        tokens = torch.tensor(next_tokens, device=tokens.device)
+        self.inference.rearrange_kv_cache(source_indices)
+
+        # add newly finished sequences to self.finished_sequences
+        assert len(self.finished_sequences) == len(finished_sequences)
+        for previously_finished, newly_finished in zip(self.finished_sequences, finished_sequences):
+            for seq in sorted(newly_finished, key=newly_finished.get, reverse=True):
+                if len(previously_finished) >= self.max_candidates:
+                    break  # the candidate list is full
+                previously_finished[seq] = newly_finished[seq]
+
+        # mark as completed if all audio has enough number of samples
+        completed = all(
+            len(sequences) >= self.max_candidates for sequences in self.finished_sequences
+        )
+        return tokens, completed
+
+    def finalize(self, preceding_tokens: Tensor, sum_logprobs: Tensor):
+        # collect all finished sequences, including patience, and add unfinished ones if not enough
+        sum_logprobs = sum_logprobs.cpu()
+        for i, sequences in enumerate(self.finished_sequences):
+            if len(sequences) < self.beam_size:  # when not enough sequences are finished
+                for j in list(np.argsort(sum_logprobs[i]))[::-1]:
+                    sequence = preceding_tokens[i, j].tolist() + [self.eot]
+                    sequences[tuple(sequence)] = sum_logprobs[i][j].item()
+                    if len(sequences) >= self.beam_size:
+                        break
+
+        # print(f'self.finished_sequences = {self.finished_sequences}')
+
+        tokens: List[List[Tensor]] = [
+            [torch.tensor(seq) for seq in sequences.keys()] for sequences in self.finished_sequences
+        ]
+        sum_logprobs: List[List[float]] = [
+            list(sequences.values()) for sequences in self.finished_sequences
+        ]
+        return tokens, sum_logprobs
+
+
+class LogitFilter:
+    def apply(self, logits: Tensor, tokens: Tensor) -> None:
+        """Apply any filtering or masking to logits in-place
+
+        Parameters
+        ----------
+        logits : Tensor, shape = (n_batch, vocab_size)
+            per-token logits of the probability distribution at the current step
+
+        tokens : Tensor, shape = (n_batch, current_sequence_length)
+            all tokens in the context so far, including the prefix and sot_sequence tokens
+
+        """
+        raise NotImplementedError
+
+
+class SuppressBlank(LogitFilter):
+    def __init__(self, tokenizer: Tokenizer, sample_begin: int):
+        self.tokenizer = tokenizer
+        self.sample_begin = sample_begin
+
+    def apply(self, logits: Tensor, tokens: Tensor):
+        if tokens.shape[1] == self.sample_begin:
+            logits[:, self.tokenizer.encode(" ") + [self.tokenizer.eot]] = -np.inf
+
+
+class SuppressTokens(LogitFilter):
+    def __init__(self, suppress_tokens: Sequence[int]):
+        self.suppress_tokens = list(suppress_tokens)
+
+    def apply(self, logits: Tensor, tokens: Tensor):
+        logits[:, self.suppress_tokens] = -np.inf
+
+
+class ApplyTimestampRules(LogitFilter):
+    def __init__(
+        self, tokenizer: Tokenizer, sample_begin: int, max_initial_timestamp_index: Optional[int]
+    ):
+        self.tokenizer = tokenizer
+        self.sample_begin = sample_begin
+        self.max_initial_timestamp_index = max_initial_timestamp_index
+
+    def apply(self, logits: Tensor, tokens: Tensor):
+        # suppress <|notimestamps|> which is handled by without_timestamps
+        if self.tokenizer.no_timestamps is not None:
+            logits[:, self.tokenizer.no_timestamps] = -np.inf
+
+        # timestamps have to appear in pairs, except directly before EOT; mask logits accordingly
+        for k in range(tokens.shape[0]):
+            seq = [t for t in tokens[k, self.sample_begin :].tolist()]
+            last_was_timestamp = len(seq) >= 1 and seq[-1] >= self.tokenizer.timestamp_begin
+            penultimate_was_timestamp = len(seq) < 2 or seq[-2] >= self.tokenizer.timestamp_begin
+
+            if last_was_timestamp:
+                if penultimate_was_timestamp:  # has to be non-timestamp
+                    logits[k, self.tokenizer.timestamp_begin :] = -np.inf
+                else:  # cannot be normal text tokens
+                    logits[k, : self.tokenizer.eot] = -np.inf
+
+        # apply the `max_initial_timestamp` option
+        if tokens.shape[1] == self.sample_begin and self.max_initial_timestamp_index is not None:
+            last_allowed = self.tokenizer.timestamp_begin + self.max_initial_timestamp_index
+            logits[:, last_allowed + 1 :] = -np.inf
+
+        # if sum of probability over timestamps is above any other token, sample timestamp
+        logprobs = F.log_softmax(logits.float(), dim=-1)
+        for k in range(tokens.shape[0]):
+            timestamp_logprob = logprobs[k, self.tokenizer.timestamp_begin :].logsumexp(dim=-1)
+            max_text_token_logprob = logprobs[k, : self.tokenizer.timestamp_begin].max()
+            if timestamp_logprob > max_text_token_logprob:
+                logits[k, : self.tokenizer.timestamp_begin] = -np.inf
+
+
+class DecodingTask:
+    inference: Inference
+    sequence_ranker: SequenceRanker
+    decoder: TokenDecoder
+    logit_filters: List[LogitFilter]
+
+    def __init__(self, model: "Whisper", options: DecodingOptions):
+        self.model = model
+
+        language = options.language or "en"
+        tokenizer = get_tokenizer(model.is_multilingual, language=language, task=options.task)
+        self.tokenizer: Tokenizer = tokenizer
+        self.options: DecodingOptions = self._verify_options(options)
+
+        self.n_group: int = options.beam_size or options.best_of or 1
+        self.n_ctx: int = model.dims.n_text_ctx
+        self.sample_len: int = options.sample_len or model.dims.n_text_ctx // 2
+
+        self.sot_sequence: Tuple[int] = tokenizer.sot_sequence
+        if self.options.without_timestamps:
+            self.sot_sequence = tokenizer.sot_sequence_including_notimestamps
+
+        self.initial_tokens: Tuple[int] = self._get_initial_tokens()
+        self.sample_begin: int = len(self.initial_tokens)
+        self.sot_index: int = self.initial_tokens.index(tokenizer.sot)
+
+        # inference: implements the forward pass through the decoder, including kv caching
+        self.inference = PyTorchInference(model, len(self.initial_tokens))
+
+        # sequence ranker: implements how to rank a group of sampled sequences
+        self.sequence_ranker = MaximumLikelihoodRanker(options.length_penalty)
+
+        # decoder: implements how to select the next tokens, given the autoregressive distribution
+        if options.beam_size is not None:
+            self.decoder = BeamSearchDecoder(
+                options.beam_size, tokenizer.eot, self.inference, options.patience
+            )
+        else:
+            self.decoder = GreedyDecoder(options.temperature, tokenizer.eot)
+
+        # logit filters: applies various rules to suppress or penalize certain tokens
+        self.logit_filters = []
+        if self.options.suppress_blank:
+            self.logit_filters.append(SuppressBlank(self.tokenizer, self.sample_begin))
+        if self.options.suppress_tokens:
+            self.logit_filters.append(SuppressTokens(self._get_suppress_tokens()))
+        if not options.without_timestamps:
+            precision = CHUNK_LENGTH / model.dims.n_audio_ctx  # usually 0.02 seconds
+            max_initial_timestamp_index = None
+            if options.max_initial_timestamp:
+                max_initial_timestamp_index = round(self.options.max_initial_timestamp / precision)
+            self.logit_filters.append(
+                ApplyTimestampRules(tokenizer, self.sample_begin, max_initial_timestamp_index)
+            )
+
+    def _verify_options(self, options: DecodingOptions) -> DecodingOptions:
+        if options.beam_size is not None and options.best_of is not None:
+            raise ValueError("beam_size and best_of can't be given together")
+        if options.temperature == 0:
+            if options.best_of is not None:
+                raise ValueError("best_of with greedy sampling (T=0) is not compatible")
+        if options.patience is not None and options.beam_size is None:
+            raise ValueError("patience requires beam_size to be given")
+        if options.length_penalty is not None and not (0 <= options.length_penalty <= 1):
+            raise ValueError("length_penalty (alpha) should be a value between 0 and 1")
+
+        return options
+
+    def _get_initial_tokens(self) -> Tuple[int]:
+        tokens = list(self.sot_sequence)
+        prefix = self.options.prefix
+        prompt = self.options.prompt
+
+        if prefix:
+            prefix_tokens = (
+                self.tokenizer.encode(" " + prefix.strip()) if isinstance(prefix, str) else prefix
+            )
+            if self.sample_len is not None:
+                max_prefix_len = self.n_ctx // 2 - self.sample_len
+                prefix_tokens = prefix_tokens[-max_prefix_len:]
+            tokens = tokens + prefix_tokens
+
+        if prompt:
+            prompt_tokens = (
+                self.tokenizer.encode(" " + prompt.strip()) if isinstance(prompt, str) else prompt
+            )
+            tokens = [self.tokenizer.sot_prev] + prompt_tokens[-(self.n_ctx // 2 - 1) :] + tokens
+
+        return tuple(tokens)
+
+    def _get_suppress_tokens(self) -> Tuple[int]:
+        suppress_tokens = self.options.suppress_tokens
+
+        if isinstance(suppress_tokens, str):
+            suppress_tokens = [int(t) for t in suppress_tokens.split(",")]
+
+        if -1 in suppress_tokens:
+            suppress_tokens = [t for t in suppress_tokens if t >= 0]
+            suppress_tokens.extend(self.tokenizer.non_speech_tokens)
+        elif suppress_tokens is None or len(suppress_tokens) == 0:
+            suppress_tokens = []  # interpret empty string as an empty list
+        else:
+            assert isinstance(suppress_tokens, list), "suppress_tokens must be a list"
+
+        suppress_tokens.extend(
+            [self.tokenizer.sot, self.tokenizer.sot_prev, self.tokenizer.sot_lm]
+        )
+        if self.tokenizer.no_speech is not None:
+            # no-speech probability is collected separately
+            suppress_tokens.append(self.tokenizer.no_speech)
+
+        return tuple(sorted(set(suppress_tokens)))
+
+    def _get_audio_features(self, mel: Tensor):
+        if self.options.fp16:
+            mel = mel.half()
+
+        if mel.shape[-2:] == (self.model.dims.n_audio_ctx, self.model.dims.n_audio_state):
+            # encoded audio features are given; skip audio encoding
+            audio_features = mel
+        else:
+            audio_features = self.model.encoder(mel)
+
+        if audio_features.dtype != (torch.float16 if self.options.fp16 else torch.float32):
+            return TypeError(f"audio_features has an incorrect dtype: {audio_features.dtype}")
+
+        return audio_features
+
+    def _detect_language(self, audio_features: Tensor, tokens: Tensor):
+        languages = [self.options.language] * audio_features.shape[0]
+        lang_probs = None
+
+        if self.options.language is None or self.options.task == "lang_id":
+            lang_tokens, lang_probs = self.model.detect_language(audio_features, self.tokenizer)
+            languages = [max(probs, key=probs.get) for probs in lang_probs]
+            if self.options.language is None:
+                tokens[:, self.sot_index + 1] = lang_tokens  # write language tokens
+
+        return languages, lang_probs
+
+    def _main_loop(self, audio_features: Tensor, tokens: Tensor):
+        assert audio_features.shape[0] == tokens.shape[0]
+        n_batch = tokens.shape[0]
+        sum_logprobs: Tensor = torch.zeros(n_batch, device=audio_features.device)
+        no_speech_probs = [np.nan] * n_batch
+
+        try:
+            for i in range(self.sample_len):
+                logits = self.inference.logits(tokens, audio_features)
+
+                if i == 0 and self.tokenizer.no_speech is not None:  # save no_speech_probs
+                    probs_at_sot = logits[:, self.sot_index].float().softmax(dim=-1)
+                    no_speech_probs = probs_at_sot[:, self.tokenizer.no_speech].tolist()
+
+                # now we need to consider the logits at the last token only
+                logits = logits[:, -1]
+
+                # apply the logit filters, e.g. for suppressing or applying penalty to
+                for logit_filter in self.logit_filters:
+                    logit_filter.apply(logits, tokens)
+
+                # expand the tokens tensor with the selected next tokens
+                tokens, completed = self.decoder.update(tokens, logits, sum_logprobs)
+
+                if completed or tokens.shape[-1] > self.n_ctx:
+                    break
+        finally:
+            self.inference.cleanup_caching()
+
+        return tokens, sum_logprobs, no_speech_probs
+
+    @torch.no_grad()
+    def run(self, mel: Tensor) -> List[DecodingResult]:
+        self.decoder.reset()
+        tokenizer: Tokenizer = self.tokenizer
+        n_audio: int = mel.shape[0]
+
+        audio_features: Tensor = self._get_audio_features(mel)  # encoder forward pass
+        tokens: Tensor = torch.tensor([self.initial_tokens]).repeat(n_audio, 1)
+
+        # detect language if requested, overwriting the language token
+        languages, language_probs = self._detect_language(audio_features, tokens)
+        if self.options.task == "lang_id":
+            return [
+                DecodingResult(
+                    audio_features=features, language=language, language_probs=probs
+                )
+                for features, language, probs in zip(
+                    audio_features, languages, language_probs
+                )
+            ]
+
+        # repeat text tensors by the group size, for beam search or best-of-n sampling
+        audio_features = audio_features.repeat_interleave(self.n_group, dim=0)
+        tokens = tokens.repeat_interleave(self.n_group, dim=0).to(audio_features.device)
+
+        # call the main sampling loop
+        # print(audio_features.shape, tokens.shape)     # torch.Size([1, 1500, 1280]) torch.Size([50, 3])
+        tokens, sum_logprobs, no_speech_probs = self._main_loop(audio_features, tokens)
+
+        # reshape the tensors to have (n_audio, n_group) as the first two dimensions
+        audio_features = audio_features[:: self.n_group]
+        no_speech_probs = no_speech_probs[:: self.n_group]
+        assert audio_features.shape[0] == len(no_speech_probs) == n_audio
+
+        tokens = tokens.reshape(n_audio, self.n_group, -1)
+        sum_logprobs = sum_logprobs.reshape(n_audio, self.n_group)
+
+        # get the final candidates for each group, and slice between the first sampled token and EOT
+        tokens, sum_logprobs = self.decoder.finalize(tokens, sum_logprobs)
+        tokens: List[List[Tensor]] = [
+            [t[self.sample_begin: (t == tokenizer.eot).nonzero()[0, 0]] for t in s]
+            for s in tokens
+        ]
+
+        # select the top-ranked sample in each group
+        selected = self.sequence_ranker.rank(tokens, sum_logprobs)
+        tokens: List[List[int]] = [t[i].tolist() for i, t in zip(selected, tokens)]
+        texts: List[str] = [tokenizer.decode(t).strip() for t in tokens]
+
+        sum_logprobs: List[float] = [lp[i] for i, lp in zip(selected, sum_logprobs)]
+        avg_logprobs: List[float] = [
+            lp / (len(t) + 1) for t, lp in zip(tokens, sum_logprobs)
+        ]
+
+        fields = (
+            texts,
+            languages,
+            tokens,
+            audio_features,
+            avg_logprobs,
+            no_speech_probs,
+        )
+        if len(set(map(len, fields))) != 1:
+            raise RuntimeError(f"inconsistent result lengths: {list(map(len, fields))}")
+
+        return [
+            DecodingResult(
+                audio_features=features,
+                language=language,
+                tokens=tokens,
+                text=text,
+                avg_logprob=avg_logprob,
+                no_speech_prob=no_speech_prob,
+                temperature=self.options.temperature,
+                compression_ratio=compression_ratio(text),
+            )
+            for text, language, tokens, features, avg_logprob, no_speech_prob in zip(
+                *fields
+            )
+        ]
+
+    @torch.no_grad()
+    def run1(self, mel: Tensor) -> List[DecodingResult]:
+        self.decoder.reset()
+        tokenizer: Tokenizer = self.tokenizer
+        n_audio: int = mel.shape[0]
+
+        audio_features: Tensor = self._get_audio_features(mel)  # encoder forward pass
+        tokens: Tensor = torch.tensor([self.initial_tokens]).repeat(n_audio, 1)
+
+        # detect language if requested, overwriting the language token
+        languages, language_probs = self._detect_language(audio_features, tokens)
+        if self.options.task == "lang_id":
+            return [
+                DecodingResult(audio_features=features, language=language, language_probs=probs)
+                for features, language, probs in zip(audio_features, languages, language_probs)
+            ]
+
+        # repeat the audio & text tensors by the group size, for beam search or best-of-n sampling
+        audio_features = audio_features.repeat_interleave(self.n_group, dim=0)
+        tokens = tokens.repeat_interleave(self.n_group, dim=0).to(audio_features.device)
+
+        # call the main sampling loop
+        tokens, sum_logprobs, no_speech_probs = self._main_loop(audio_features, tokens)
+
+        # reshape the tensors to have (n_audio, n_group) as the first two dimensions
+        audio_features = audio_features[:: self.n_group]
+        no_speech_probs = no_speech_probs[:: self.n_group]
+        assert audio_features.shape[0] == len(no_speech_probs) == n_audio
+
+        tokens = tokens.reshape(n_audio, self.n_group, -1)
+        sum_logprobs = sum_logprobs.reshape(n_audio, self.n_group)
+
+        # get the final candidates for each group, and slice between the first sampled token and EOT
+        tokens, sum_logprobs = self.decoder.finalize(tokens, sum_logprobs)
+        tokens: List[List[Tensor]] = [
+            [t[self.sample_begin : (t == tokenizer.eot).nonzero()[0, 0]] for t in s] for s in tokens
+        ]
+
+        # select the top-ranked sample in each group
+        # selected = self.sequence_ranker.rank(tokens, sum_logprobs)
+        # print(f'selected = {selected}\n')
+
+        tokens = [[i.tolist() for i in t] for t in tokens]
+        avg_logprobs: List[float] = [[ilp / (len(it) + 1) for it, ilp in zip(t, lp)] for t, lp in zip(tokens, sum_logprobs)]
+        texts = [[tokenizer.decode(i).strip() for i in t] for t in tokens]
+
+        # print(f'tokens = {tokens}')
+        # print(f'avg_logprobs = {avg_logprobs}')
+        # print(f'texts = {texts}')
+
+        import heapq
+        top50_list = [heapq.nlargest(50, range(len(a)), a.__getitem__) for a in avg_logprobs]
+        # print(f'top50_list = {top50_list}')
+
+        texts = [[text[i] for i in top50] for text, top50 in zip(texts, top50_list)]
+
+        return texts
+
+    @torch.no_grad()
+    def run_wer(self, mel: Tensor) -> List[DecodingResult]:
+        self.decoder.reset()
+        tokenizer: Tokenizer = self.tokenizer
+        n_audio: int = mel.shape[0]
+
+        audio_features: Tensor = self._get_audio_features(mel)  # encoder forward pass
+        tokens: Tensor = torch.tensor([self.initial_tokens]).repeat(n_audio, 1)
+
+        # detect language if requested, overwriting the language token
+        languages, language_probs = self._detect_language(audio_features, tokens)
+        if self.options.task == "lang_id":
+            return [
+                DecodingResult(audio_features=features, language=language, language_probs=probs)
+                for features, language, probs in zip(audio_features, languages, language_probs)
+            ]
+
+        # repeat the audio & text tensors by the group size, for beam search or best-of-n sampling
+        audio_features = audio_features.repeat_interleave(self.n_group, dim=0)
+        tokens = tokens.repeat_interleave(self.n_group, dim=0).to(audio_features.device)
+
+        # call the main sampling loop
+        tokens, sum_logprobs, no_speech_probs = self._main_loop(audio_features, tokens)
+
+        # reshape the tensors to have (n_audio, n_group) as the first two dimensions
+        audio_features = audio_features[:: self.n_group]
+        no_speech_probs = no_speech_probs[:: self.n_group]
+        assert audio_features.shape[0] == len(no_speech_probs) == n_audio
+
+        tokens = tokens.reshape(n_audio, self.n_group, -1)
+        sum_logprobs = sum_logprobs.reshape(n_audio, self.n_group)
+
+        # get the final candidates for each group, and slice between the first sampled token and EOT
+        tokens, sum_logprobs = self.decoder.finalize(tokens, sum_logprobs)
+        tokens: List[List[Tensor]] = [
+            [t[self.sample_begin: (t == tokenizer.eot).nonzero()[0, 0]] for t in s] for s in tokens
+        ]
+
+        # select the top-ranked sample in each group
+        # selected = self.sequence_ranker.rank(tokens, sum_logprobs)
+        # print(f'selected = {selected}\n')
+
+        tokens = [[i.tolist() for i in t] for t in tokens]
+        avg_logprobs: List[float] = [[ilp / (len(it) + 1) for it, ilp in zip(t, lp)] for t, lp in
+                                     zip(tokens, sum_logprobs)]
+        texts = [[tokenizer.decode(i).strip() for i in t] for t in tokens]
+
+        # print(f'tokens = {tokens}')
+        # print(f'avg_logprobs = {avg_logprobs}')
+        # print(f'texts = {texts}')
+
+        import heapq
+        top5_list = [heapq.nlargest(5, range(len(a)), a.__getitem__) for a in avg_logprobs]
+        # print(f'top5_list = {top5_list}')
+
+        texts = [[text[i] for i in top5] for text, top5 in zip(texts, top5_list)]
+
+        return texts
+
+    @torch.no_grad()
+    def run_score(self, mel: Tensor) -> List[DecodingResult]:
+        self.decoder.reset()
+        tokenizer: Tokenizer = self.tokenizer
+        n_audio: int = mel.shape[0]
+
+        audio_features: Tensor = self._get_audio_features(mel)  # encoder forward pass
+        tokens: Tensor = torch.tensor([self.initial_tokens]).repeat(n_audio, 1)
+
+        # detect language if requested, overwriting the language token
+        languages, language_probs = self._detect_language(audio_features, tokens)
+        if self.options.task == "lang_id":
+            return [
+                DecodingResult(audio_features=features, language=language, language_probs=probs)
+                for features, language, probs in zip(audio_features, languages, language_probs)
+            ]
+
+        # repeat the audio & text tensors by the group size, for beam search or best-of-n sampling
+        audio_features = audio_features.repeat_interleave(self.n_group, dim=0)
+        tokens = tokens.repeat_interleave(self.n_group, dim=0).to(audio_features.device)
+
+        # call the main sampling loop
+        tokens, sum_logprobs, no_speech_probs = self._main_loop(audio_features, tokens)
+
+        # reshape the tensors to have (n_audio, n_group) as the first two dimensions
+        audio_features = audio_features[:: self.n_group]
+        no_speech_probs = no_speech_probs[:: self.n_group]
+        assert audio_features.shape[0] == len(no_speech_probs) == n_audio
+
+        tokens = tokens.reshape(n_audio, self.n_group, -1)
+        sum_logprobs = sum_logprobs.reshape(n_audio, self.n_group)
+
+        # get the final candidates for each group, and slice between the first sampled token and EOT
+        tokens, sum_logprobs = self.decoder.finalize(tokens, sum_logprobs)
+        tokens: List[List[Tensor]] = [
+            [t[self.sample_begin: (t == tokenizer.eot).nonzero()[0, 0]] for t in s] for s in tokens
+        ]
+
+        # select the top-ranked sample in each group
+        # selected = self.sequence_ranker.rank(tokens, sum_logprobs)
+        # print(f'selected = {selected}\n')
+
+        tokens = [[i.tolist() for i in t] for t in tokens]
+        avg_logprobs: List[float] = [[ilp / (len(it) + 1) for it, ilp in zip(t, lp)] for t, lp in
+                                     zip(tokens, sum_logprobs)]
+        texts = [[tokenizer.decode(i).strip() for i in t] for t in tokens]
+
+        # print(f'tokens = {tokens}')
+        # print(f'avg_logprobs = {avg_logprobs}')
+        # print(f'texts = {texts}')
+
+        import heapq
+        top50_list = [heapq.nlargest(80, range(len(a)), a.__getitem__) for a in avg_logprobs]
+        # print(f'top50_list = {top50_list}')
+
+        texts = [[text[i] for i in top50] for text, top50 in zip(texts, top50_list)]
+        scores = [[score[i] for i in top50] for score, top50 in zip(avg_logprobs, top50_list)]
+
+        return texts, scores
+
+@torch.no_grad()
+def decode(
+    model: "Whisper",
+    mel: Tensor,
+    options: DecodingOptions = DecodingOptions(),
+    **kwargs,
+) -> Union[DecodingResult, List[DecodingResult]]:
+    """
+    Performs decoding of 30-second audio segment(s), provided as Mel spectrogram(s).
+
+    Parameters
+    ----------
+    model: Whisper
+        the Whisper model instance
+
+    mel: torch.Tensor, shape = (80, 3000) or (*, 80, 3000)
+        A tensor containing the Mel spectrogram(s)
+
+    options: DecodingOptions
+        A dataclass that contains all necessary options for decoding 30-second segments
+
+    Returns
+    -------
+    result: Union[DecodingResult, List[DecodingResult]]
+        The result(s) of decoding contained in `DecodingResult` dataclass instance(s)
+    """
+    if single := mel.ndim == 2:
+        mel = mel.unsqueeze(0)
+
+    if kwargs:
+        options = replace(options, **kwargs)
+
+    result = DecodingTask(model, options).run(mel)
+
+    return result[0] if single else result
+
+@torch.no_grad()
+def decode1(model: "Whisper", mel: Tensor, options: DecodingOptions = DecodingOptions()) -> Union[DecodingResult, List[DecodingResult]]:
+    """
+    Performs decoding of 30-second audio segment(s), provided as Mel spectrogram(s).
+
+    Parameters
+    ----------
+    model: Whisper
+        the Whisper model instance
+
+    mel: torch.Tensor, shape = (80, 3000) or (*, 80, 3000)
+        A tensor containing the Mel spectrogram(s)
+
+    options: DecodingOptions
+        A dataclass that contains all necessary options for decoding 30-second segments
+
+    Returns
+    -------
+    result: Union[DecodingResult, List[DecodingResult]]
+        The result(s) of decoding contained in `DecodingResult` dataclass instance(s)
+    """
+    single = mel.ndim == 2
+    if single:
+        mel = mel.unsqueeze(0)
+
+    result = DecodingTask(model, options).run1(mel)
+    
+    if single:
+        result = result[0]
+
+    return result
+
+
+@torch.no_grad()
+def decode_wer(model: "Whisper", mel: Tensor, options: DecodingOptions = DecodingOptions()) -> Union[
+    DecodingResult, List[DecodingResult]]:
+    """
+    Performs decoding of 30-second audio segment(s), provided as Mel spectrogram(s).
+
+    Parameters
+    ----------
+    model: Whisper
+        the Whisper model instance
+
+    mel: torch.Tensor, shape = (80, 3000) or (*, 80, 3000)
+        A tensor containing the Mel spectrogram(s)
+
+    options: DecodingOptions
+        A dataclass that contains all necessary options for decoding 30-second segments
+
+    Returns
+    -------
+    result: Union[DecodingResult, List[DecodingResult]]
+        The result(s) of decoding contained in `DecodingResult` dataclass instance(s)
+    """
+    single = mel.ndim == 2
+    if single:
+        mel = mel.unsqueeze(0)
+
+    result = DecodingTask(model, options).run_wer(mel)
+
+    if single:
+        result = result[0]
+
+    return result
+
+
+@torch.no_grad()
+def decode_score(model: "Whisper", mel: Tensor, options: DecodingOptions = DecodingOptions()) -> Union[
+    DecodingResult, List[DecodingResult]]:
+    """
+    Performs decoding of 30-second audio segment(s), provided as Mel spectrogram(s).
+
+    Parameters
+    ----------
+    model: Whisper
+        the Whisper model instance
+
+    mel: torch.Tensor, shape = (80, 3000) or (*, 80, 3000)
+        A tensor containing the Mel spectrogram(s)
+
+    options: DecodingOptions
+        A dataclass that contains all necessary options for decoding 30-second segments
+
+    Returns
+    -------
+    result: Union[DecodingResult, List[DecodingResult]]
+        The result(s) of decoding contained in `DecodingResult` dataclass instance(s)
+    """
+    single = mel.ndim == 2
+    if single:
+        mel = mel.unsqueeze(0)
+
+    texts, scores = DecodingTask(model, options).run_score(mel)
+
+    if single:
+        texts = texts[0]
+        scores = scores[0]
+
+    return texts, scores

generate_robust_hp.py

@@ -0,0 +1,212 @@
+import whisper
+import re
+import sys
+import os, random, copy
+import numpy as np
+import torch
+import pandas as pd
+import torchaudio
+from tqdm.notebook import tqdm
+import collections, json
+import editdistance
+from whisper.normalizers import EnglishTextNormalizer
+from argparse import ArgumentParser
+from num2words import num2words
+sys.path.append('/home3/huyuchen/pytorch_workplace/jiwer')
+from jiwer import wer_embdiff
+import fasttext
+from huggingface_hub import hf_hub_download
+from pathlib import Path
+from typing import Optional
+from sentencepiece import SentencePieceProcessor, SentencePieceTrainer
+from sentence_transformers import SentenceTransformer
+from argparse import ArgumentParser
+from evaluate import load
+from lit_gpt.tokenizer import Tokenizer
+eval_wer = load("wer")
+normalizer = EnglishTextNormalizer()
+
+checkpoint_dir = Path('/home3/huyuchen/pytorch_workplace/wgpt/checkpoints/Llama-2-7b-hf')
+tokenizer = Tokenizer(checkpoint_dir)
+
+sbert_model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
+
+
+def calculate_wer(all_hypo, all_refer):
+    return eval_wer.compute(predictions=all_hypo, references=all_refer)
+
+def word_emb_diff(reference, hypothesis):
+    output, edit_ops = wer_embdiff(reference, hypothesis)
+    ref_words, hypo_words = output.references[0], output.hypotheses[0]
+
+    emb_diffs = []
+    for op in edit_ops:
+        if op.tag == 'replace':
+            ref_word, hypo_word = ref_words[op.src_pos], hypo_words[op.dest_pos]
+        elif op.tag == 'delete':
+            ref_word, hypo_word = ref_words[op.src_pos], None
+        elif op.tag == 'insert':
+            ref_word, hypo_word = None, hypo_words[op.dest_pos]
+        else:
+            continue
+
+        ref_emb = torch.from_numpy(sbert_model.encode([ref_word])[0]) if ref_word else torch.zeros([384])
+        hypo_emb = torch.from_numpy(sbert_model.encode([hypo_word])[0]) if hypo_word else torch.zeros([384])
+
+        emb_diff = ref_emb - hypo_emb
+        emb_diffs.append(emb_diff)
+
+        # print('word', hypo_emb.mean(), ref_emb.mean(), emb_diff.mean())
+
+    if len(emb_diffs) == 0:
+        return torch.zeros([384])
+    else:
+        return torch.stack(emb_diffs, dim=0).mean(dim=0)
+
+def sent_emb_diff(reference, hypothesis):
+    embeddings = sbert_model.encode([reference, hypothesis])
+    ref_emb, hypo_emb = torch.from_numpy(embeddings[0]), torch.from_numpy(embeddings[1])
+    emb_diff = ref_emb - hypo_emb
+    # print('sentence', hypo_emb.mean(), ref_emb.mean(), emb_diff.mean())
+
+    return emb_diff
+
+def generate_prompt(input1, input2):
+    return (
+        f"Below is the best-hypotheses transcribed from speech recognition system. Please try to revise it using the words which are only included into other-hypothesis, and write the response for the true transcription.\n\n### Best-hypothesis:\n{input1}\n\n### Other-hypothesis:\n{input2}\n\n### Response:\n"
+    )
+
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+model = whisper.load_model('large-v2')
+
+f_noisy_wav = open(f'noisy_wav.scp', 'r')
+f_clean_wav = open(f'clean_wav.scp', 'r')
+f_text = open(f'text', 'r')
+
+id = 0
+pt_file = []
+all_hypo, all_refer = [], []
+for line in f_noisy_wav.readlines():
+    utt_id, audio_path = line.strip().split()[0], line.strip().split()[1]
+    clean_line = f_clean_wav.readline()
+    clean_utt_id, clean_audio_path = clean_line.strip().split()[0], clean_line.strip().split()[1]
+    assert clean_utt_id == utt_id, (line, clean_line)
+    gt = ' '.join(f_text.readline().strip().split()[1:])
+    audio = whisper.load_audio(audio_path)
+    audio = whisper.pad_or_trim(audio)
+    mel = whisper.log_mel_spectrogram(audio).to(model.device)
+    options = whisper.DecodingOptions(language='en', beam_size=50)
+    texts, confidences = whisper.decode_score(model, mel, options)
+
+    ## noisy audio feats
+    audio_features = model.encoder(mel.unsqueeze(0))[0]
+    
+    ## clean audio feats
+    clean_audio = whisper.load_audio(clean_audio_path)
+    clean_audio = whisper.pad_or_trim(clean_audio)
+    clean_mel = whisper.log_mel_spectrogram(clean_audio).to(model.device)
+    clean_audio_features = model.encoder(clean_mel.unsqueeze(0))[0]
+
+    input, score = [], []
+    for text, confidence in zip(texts, confidences):
+        if len(input) < 5 and len(text) > 0 and text not in input:
+            input.append(text)
+            score.append(confidence)
+
+    # print('before', input, score, len(input))
+
+    if len(input) < 5:
+        options = whisper.DecodingOptions(language='en', temperature=1.2)
+        for _ in range(5 - len(input)):
+            result = whisper.decode(model, mel, options)
+            text, condidence = result.text, result.avg_logprob
+            if text in input:
+                continue
+            inserted = False
+            for i in range(len(input)):
+                if condidence > score[i]:
+                    input.insert(i, text)
+                    score.insert(i, condidence)
+                    inserted = True
+                    break
+            if not inserted:
+                input.append(text)
+                score.append(condidence)
+
+    # print('after ', input, score, len(input))
+
+    if len(input) < 5:
+        num_to_add = 5 - len(input)
+        for _ in range(num_to_add):
+            rand_id = random.randint(0, len(input) - 1)
+            rep_input, rep_score = copy.deepcopy(input[rand_id]), copy.deepcopy(score[rand_id])
+            input.insert(rand_id + 1, rep_input)
+            score.insert(rand_id + 1, rep_score)
+
+    for i in range(len(input)):
+        try:
+            text = normalizer(input[i])
+            text = re.sub(r"[-+]?\d*\.?\d+|\d+%?", lambda m: num2words(m.group()), text).replace('%', ' percent')
+        except Exception:
+            text = normalizer(input[i])
+            print(f'input exception: {text}')
+        input[i] = text if len(text) > 0 else '<UNK>'
+
+    try:
+        output = normalizer(gt)
+        output = re.sub(r"[-+]?\d*\.?\d+|\d+%?", lambda m: num2words(m.group()), output).replace('%', ' percent')
+    except Exception:
+        output = normalizer(gt)
+        print(f'output exception: {output}')
+    output = output if len(output) > 0 else '<UNK>'
+
+    cur_wer = calculate_wer([input[0]], [output])
+
+    # calculate emb diff
+    we_diffs, se_diffs = [], []
+    for i in range(5):
+        for j in range(i + 1, 5):
+            we_diffs.append(word_emb_diff(input[i], input[j]))
+            se_diffs.append(sent_emb_diff(input[i], input[j]))
+
+    we_diff = torch.stack(we_diffs, dim=0)      # [10, 384]
+    se_diff = torch.stack(se_diffs, dim=0)      # [10, 384]
+    emb_diff = torch.cat([we_diff, se_diff], dim=0)     # [20, 384]
+    
+    # generate ids
+    input1 = input[0] + '.'
+    input2 = '. '.join(input[1:]) + '.'
+
+    full_prompt = generate_prompt(input1, input2)
+    full_prompt_and_response = full_prompt + output
+    encoded_full_prompt = tokenizer.encode(full_prompt, max_length=1024)
+    encoded_full_prompt_and_response = tokenizer.encode(full_prompt_and_response, eos=True, max_length=1024)
+
+    labels = encoded_full_prompt_and_response.clone()
+    labels[: len(encoded_full_prompt)] = -1
+
+
+    data = {"id": utt_id, "input_ids": encoded_full_prompt_and_response, "input_ids_no_response": encoded_full_prompt, "labels": labels,
+             "input": input, 'ground_truth': output, "am_score": score, 'emb_diff': emb_diff, 'audio_features': noisy_audio_features, 
+             'clean_audio_features': clean_audio_features}
+
+    pt_file.append(data)
+
+    # calculate wer
+    id += 1
+    print(f'utterance {id}: wer = {cur_wer}, confidence = {score[0]}')
+    all_hypo.append(input[0])
+    all_refer.append(output)
+
+
+torch.save(pt_file, f'/home3/huyuchen/pytorch_workplace/wllama/hypo_paradise_v2/train_rats.pt')
+
+
+f_noisy_wav.close()
+f_clean_wav.close()
+f_text.close()
+
+all_wer = calculate_wer(all_hypo, all_refer)
+print(f'all wer = {all_wer}')
+

jiwer/.github/workflows/pythonpackage.yml

@@ -0,0 +1,63 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Python package
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  style:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.7]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+    - name: Setup dependencies
+      run: |
+        poetry update
+        poetry install
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        poetry run flake8 jiwer --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        poetry run flake8 jiwer --count --exit-zero --max-complexity=10 --max-line-length=88 --statistics
+    - name: Check formatting with black
+      run: |
+        poetry run black . --check
+     
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+    - name: Install dependencies
+      run: |
+        poetry run python -m pip install --upgrade pip
+        poetry update
+        poetry install
+    - name: Test with pytest
+      run: |
+        poetry run python --version
+        poetry run pytest

jiwer/.github/workflows/pythonpublish.yml

@@ -0,0 +1,33 @@
+# This workflows will upload a Python Package using Twine when a release is created
+# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+    - name: Install dependencies
+      run: |
+        poetry run python -m pip install --upgrade pip
+        poetry update
+        poetry install
+    - name: Build and publish
+      env:
+        POETRY_HTTP_BASIC_PYPI_USERNAME: ${{ secrets.PYPI_USERNAME }}
+        POETRY_PYPI_TOKEN_PYPI:  ${{ secrets.PYPI_API_TOKEN }}
+      run: |
+        poetry publish --build

jiwer/.gitignore

@@ -0,0 +1,28 @@
+# Compiled python modules.
+*.pyc
+
+# Setuptools distribution folder.
+/dist/
+
+# Python egg metadata, regenerated from source files by setuptools.
+/*.egg-info
+
+# playground directory for running local debug code
+playground
+
+# poetry .lock file
+poetry.lock
+
+# idea specific folders
+.idea
+.vscode
+
+# virtual environments
+venv
+.venv
+
+# cache folders
+.pytest_cache
+.benchmarks
+/docs/site/
+/site/

jiwer/.mailmap

@@ -0,0 +1,6 @@
+# mail map file
+# for cleaner output of e.g. `git shortlog -nes`
+
+Nik Vaessen <[email protected]>
+Nik Vaessen <[email protected]> <[email protected]>
+Bart van Andel <[email protected]>

jiwer/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018 8x8, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

jiwer/README.md

@@ -0,0 +1,55 @@
+# JiWER
+
+JiWER is a simple and fast python package to evaluate an automatic speech recognition system.
+It supports the following measures:
+
+1. word error rate (WER)
+2. match error rate (MER)
+3. word information lost (WIL) 
+4. word information preserved (WIP) 
+5. character error rate (CER)
+
+These measures are computed with the use of the minimum-edit distance between one or more reference and hypothesis sentences.
+The minimum-edit distance is calculated using [RapidFuzz](https://github.com/maxbachmann/RapidFuzz), which uses C++ under the hood, and is therefore faster than a pure python implementation.
+
+## Documentation
+
+For further info, see the documentation at [jitsi.github.io/jiwer](https://jitsi.github.io/jiwer).
+
+## Installation
+
+You should be able to install this package using [poetry](https://python-poetry.org/docs/): 
+
+```
+$ poetry add jiwer
+```
+
+Or, if you prefer old-fashioned pip and you're using Python >= `3.7`:
+
+```bash
+$ pip install jiwer
+```
+
+## Usage
+
+The most simple use-case is computing the word error rate between two strings:
+
+```python
+from jiwer import wer
+
+reference = "hello world"
+hypothesis = "hello duck"
+
+error = wer(reference, hypothesis)
+```
+
+## Licence
+
+The jiwer package is released under the `Apache License, Version 2.0` licence by [8x8](https://www.8x8.com/).
+
+For further information, see [`LICENCE`](./LICENSE).
+
+## Reference
+
+_For a comparison between WER, MER and WIL, see: \
+Morris, Andrew & Maier, Viktoria & Green, Phil. (2004). [From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.](https://www.researchgate.net/publication/221478089_From_WER_and_RIL_to_MER_and_WIL_improved_evaluation_measures_for_connected_speech_recognition)_

jiwer/docs/cli.md

@@ -0,0 +1,29 @@
+
+JiWER provides a simple CLI, which should be available after installation. 
+
+For details, see `jiwer --help`.
+
+```text
+$ jiwer --help
+Usage: jiwer [OPTIONS]
+
+  JiWER is a python tool for computing the word-error-rate of ASR systems. To
+  use this CLI, store the reference and hypothesis sentences in a text file,
+  where each sentence is delimited by a new-line character. The text files are
+  expected to have an equal number of lines, unless the `-g` flag is used. The
+  `-g` flag joins computation of the WER by doing a global minimal alignment.
+
+Options:
+  -r, --reference PATH   Path to new-line delimited text file of reference
+                         sentences.  [required]
+  -h, --hypothesis PATH  Path to new-line delimited text file of hypothesis
+                         sentences.  [required]
+  -c, --cer              Compute CER instead of WER.
+  -a, --align            Print alignment of each sentence.
+  -g, --global           Apply a global minimal alignment between reference
+                         and hypothesis sentences before computing the WER.
+  --help                 Show this message and exit.
+```
+
+Note that the CLI does not support a custom pre-processing (as described below). Any pre-processing
+should be done on the text files manually before calling JiWER when using the CLI. 

jiwer/docs/gen_ref_pages.py

@@ -0,0 +1,28 @@
+"""Generate the code reference pages and navigation."""
+
+from pathlib import Path
+import mkdocs_gen_files
+
+nav = mkdocs_gen_files.Nav()
+
+for path in sorted(Path("jiwer").rglob("*.py")):
+    doc_path = path.relative_to("jiwer").with_suffix(".md")
+    full_doc_path = Path("reference", doc_path)
+
+    module_path = path.relative_to("jiwer").with_suffix("")
+    parts = list(module_path.parts)
+
+    if parts[-1] == "__init__" or parts[-1] == "cli":
+        continue
+
+    nav[parts] = doc_path.as_posix()
+
+    with mkdocs_gen_files.open(full_doc_path, "w") as fd:
+        identifier = ".".join(parts)
+        print("::: " + identifier, file=fd)
+
+    mkdocs_gen_files.set_edit_path(full_doc_path, path)
+
+
+with mkdocs_gen_files.open("reference/SUMMARY.md", "w") as nav_file:
+    nav_file.writelines(nav.build_literate_nav())

jiwer/docs/index.md

@@ -0,0 +1,31 @@
+# JiWER
+
+JiWER is a simple and fast python package to evaluate an automatic speech recognition system.
+It supports the following measures:
+
+1. word error rate (WER)
+2. match error rate (MER)
+3. word information lost (WIL) 
+4. word information preserved (WIP) 
+5. character error rate (CER)
+
+These measures are computed with the use of the minimum-edit distance between one or more reference and hypothesis sentences.
+The minimum-edit distance is calculated using [RapidFuzz](https://github.com/maxbachmann/RapidFuzz), which uses C++ under the hood, and is therefore faster than a pure python implementation.
+
+# Installation
+
+You should be able to install this package using [poetry](https://python-poetry.org/docs/): 
+
+```
+$ poetry add jiwer
+```
+
+Or, if you prefer old-fashioned pip and you're using Python >= `3.7`:
+
+```bash
+$ pip install jiwer
+```
+
+
+
+

jiwer/docs/requirements.txt

@@ -0,0 +1,5 @@
+mkdocs==1.4.2
+mkdocstrings[python]==0.20.0
+mkdocs-gen-files==0.4.0
+mkdocs-literate-nav==0.6.0
+mkdocs-material==9.1.3

jiwer/docs/usage.md

@@ -0,0 +1,111 @@
+# Usage
+
+The most simple use-case is computing the word error rate between two strings:
+
+```python
+from jiwer import wer
+
+reference = "hello world"
+hypothesis = "hello duck"
+
+error = wer(reference, hypothesis)
+```
+
+Similarly, to get other measures:
+
+```python
+import jiwer
+
+reference = "hello world"
+hypothesis = "hello duck"
+
+wer = jiwer.wer(reference, hypothesis)
+mer = jiwer.mer(reference, hypothesis)
+wil = jiwer.wil(reference, hypothesis)
+
+# faster, because `compute_measures` only needs to perform the heavy lifting once:
+output = jiwer.process_words(reference, hypothesis)
+wer = output.wer
+mer = output.mer
+wil = output.wil
+```
+
+You can also compute the WER over multiple sentences:
+
+```python
+from jiwer import wer
+
+reference = ["hello world", "i like monthy python"]
+hypothesis = ["hello duck", "i like python"]
+
+error = wer(reference, hypothesis)
+```
+
+We also provide the character error rate:
+
+```python
+import jiwer
+
+reference = ["i can spell", "i hope"]
+hypothesis = ["i kan cpell", "i hop"]
+
+error = jiwer.cer(reference, hypothesis)
+
+# if you also want the alignment
+output = jiwer.process_characters(reference, hypothesis)
+error = output.cer
+```
+
+# Alignment
+
+With `jiwer.process_words`, you also get the alignment between the reference and hypothesis.
+
+We provide the alignment as a list of `(op, ref_start_idx, ref_idx_end, hyp_idx_start, hyp_idx_end)`, where `op` is one of
+    `equal`, `replace`, `delete`, or `insert`.
+
+This looks like the following:
+
+```python3
+import jiwer
+
+out = jiwer.process_words("short one here", "shoe order one")
+print(out.alignments)
+# [[[AlignmentChunk(type='insert', ref_start_idx=0, ref_end_idx=0, hyp_start_idx=0, hyp_end_idx=1), ...]]
+```
+
+To visualize the alignment, you can use `jiwer.visualize_alignment()`
+
+For example:
+
+```python3
+import jiwer
+
+out = jiwer.process_words(
+    ["short one here", "quite a bit of longer sentence"],
+    ["shoe order one", "quite bit of an even longest sentence here"],
+)
+
+print(jiwer.visualize_alignment(out))
+```
+Gives the following output
+```text
+sentence 1
+REF: **** short one here
+HYP: shoe order one ****
+        I     S        D
+
+sentence 2
+REF: quite a bit of ** ****  longer sentence ****
+HYP: quite * bit of an even longest sentence here
+           D         I    I       S             I
+
+number of sentences: 2
+substitutions=2 deletions=2 insertions=4 hits=5
+
+mer=61.54%
+wil=74.75%
+wip=25.25%
+wer=88.89%
+```
+
+Note that it also possible to visualize the character-level alignment, simply use the output of `jiwer.process_characters()` instead. 

jiwer/jiwer/__init__.py

@@ -0,0 +1,7 @@
+from .measures import *
+from .transforms import *
+from .transformations import *
+from .alignment import *
+from .process import *
+
+name = "jiwer"

jiwer/jiwer/alignment.py

@@ -0,0 +1,185 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+Utility method to visualize the alignment between one or more reference and hypothesis
+pairs.
+"""
+
+from typing import Dict, List, Tuple, Union
+
+
+from jiwer.process import CharacterOutput, WordOutput, AlignmentChunk
+
+__all__ = ["visualize_alignment"]
+
+
+def visualize_alignment(
+    output: Union[WordOutput, CharacterOutput],
+    show_measures: bool = True,
+    skip_correct: bool = True,
+) -> str:
+    """
+    Visualize the output of [jiwer.process_words][process.process_words] and
+    [jiwer.process_characters][process.process_characters]. The visualization
+    shows the alignment between each processed reference and hypothesis pair.
+    If `show_measures=True`, the output string will also contain all measures in the
+    output.
+
+    Args:
+        output: The processed output of reference and hypothesis pair(s).
+        show_measures: If enabled, the visualization will include measures like the WER
+                       or CER
+        skip_correct: If enabled, the visualization will exclude correct reference and hypothesis pairs
+
+    Returns:
+        (str): The visualization as a string
+
+    Example:
+        This code snippet
+        ```python
+        import jiwer
+
+        out = jiwer.process_words(
+            ["short one here", "quite a bit of longer sentence"],
+            ["shoe order one", "quite bit of an even longest sentence here"],
+        )
+
+        print(jiwer.visualize_alignment(out))
+        ```
+        will produce this visualization:
+        ```txt
+        sentence 1
+        REF:    # short one here
+        HYP: shoe order one    *
+                I     S        D
+
+        sentence 2
+        REF: quite a bit of  #    #  longer sentence    #
+        HYP: quite * bit of an even longest sentence here
+                   D         I    I       S             I
+
+        number of sentences: 2
+        substitutions=2 deletions=2 insertions=4 hits=5
+
+        mer=61.54%
+        wil=74.75%
+        wip=25.25%
+        wer=88.89%
+        ```
+
+        When `show_measures=False`, only the alignment will be printed:
+
+        ```txt
+        sentence 1
+        REF:    # short one here
+        HYP: shoe order one    *
+                I     S        D
+
+        sentence 2
+        REF: quite a bit of  #    #  longer sentence    #
+        HYP: quite * bit of an even longest sentence here
+                   D         I    I       S             I
+        ```
+    """
+    references = output.references
+    hypothesis = output.hypotheses
+    alignment = output.alignments
+    is_cer = isinstance(output, CharacterOutput)
+
+    final_str = ""
+    for idx, (gt, hp, chunks) in enumerate(zip(references, hypothesis, alignment)):
+        if skip_correct and len(chunks) == 1 and chunks[0].type == "equal":
+            continue
+
+        final_str += f"sentence {idx+1}\n"
+        final_str += _construct_comparison_string(
+            gt, hp, chunks, include_space_seperator=not is_cer
+        )
+        final_str += "\n"
+
+    if show_measures:
+        final_str += f"number of sentences: {len(alignment)}\n"
+        final_str += f"substitutions={output.substitutions} "
+        final_str += f"deletions={output.deletions} "
+        final_str += f"insertions={output.insertions} "
+        final_str += f"hits={output.hits}\n"
+
+        if is_cer:
+            final_str += f"\ncer={output.cer*100:.2f}%\n"
+        else:
+            final_str += f"\nmer={output.mer*100:.2f}%"
+            final_str += f"\nwil={output.wil*100:.2f}%"
+            final_str += f"\nwip={output.wip*100:.2f}%"
+            final_str += f"\nwer={output.wer*100:.2f}%\n"
+    else:
+        # remove last newline
+        final_str = final_str[:-1]
+
+    return final_str
+
+
+def _construct_comparison_string(
+    reference: List[str],
+    hypothesis: List[str],
+    ops: List[AlignmentChunk],
+    include_space_seperator: bool = False,
+) -> str:
+    ref_str = "REF: "
+    hyp_str = "HYP: "
+    op_str = "     "
+
+    for op in ops:
+        if op.type == "equal" or op.type == "substitute":
+            ref = reference[op.ref_start_idx : op.ref_end_idx]
+            hyp = hypothesis[op.hyp_start_idx : op.hyp_end_idx]
+            op_char = " " if op.type == "equal" else "s"
+        elif op.type == "delete":
+            ref = reference[op.ref_start_idx : op.ref_end_idx]
+            hyp = ["*" for _ in range(len(ref))]
+            op_char = "d"
+        elif op.type == "insert":
+            hyp = hypothesis[op.hyp_start_idx : op.hyp_end_idx]
+            ref = ["*" for _ in range(len(hyp))]
+            op_char = "i"
+        else:
+            raise ValueError(f"unparseable op name={op.type}")
+
+        op_chars = [op_char for _ in range(len(ref))]
+        for rf, hp, c in zip(ref, hyp, op_chars):
+            str_len = max(len(rf), len(hp), len(c))
+
+            if rf == "*":
+                rf = "".join(["*"] * str_len)
+            elif hp == "*":
+                hp = "".join(["*"] * str_len)
+
+            ref_str += f"{rf:>{str_len}}"
+            hyp_str += f"{hp:>{str_len}}"
+            op_str += f"{c.upper():>{str_len}}"
+
+            if include_space_seperator:
+                ref_str += " "
+                hyp_str += " "
+                op_str += " "
+
+    if include_space_seperator:
+        # remove last space
+        return f"{ref_str[:-1]}\n{hyp_str[:-1]}\n{op_str[:-1]}\n"
+    else:
+        return f"{ref_str}\n{hyp_str}\n{op_str}\n"

jiwer/jiwer/cli.py

@@ -0,0 +1,133 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+Provide a simple CLI wrapper for JiWER. The CLI does not support custom transforms.
+"""
+
+import click
+import pathlib
+
+import jiwer
+
+
+@click.command()
+@click.option(
+    "-r",
+    "--reference",
+    "reference_file",
+    type=pathlib.Path,
+    required=True,
+    help="Path to new-line delimited text file of reference sentences.",
+)
+@click.option(
+    "-h",
+    "--hypothesis",
+    "hypothesis_file",
+    type=pathlib.Path,
+    required=True,
+    help="Path to new-line delimited text file of hypothesis sentences.",
+)
+@click.option(
+    "--cer",
+    "-c",
+    "compute_cer",
+    is_flag=True,
+    default=False,
+    help="Compute CER instead of WER.",
+)
+@click.option(
+    "--align",
+    "-a",
+    "show_alignment",
+    is_flag=True,
+    default=False,
+    help="Print alignment of each sentence.",
+)
+@click.option(
+    "--global",
+    "-g",
+    "global_alignment",
+    is_flag=True,
+    default=False,
+    help="Apply a global minimal alignment between reference and hypothesis sentences "
+    "before computing the WER.",
+)
+def cli(
+    reference_file: pathlib.Path,
+    hypothesis_file: pathlib.Path,
+    compute_cer: bool,
+    show_alignment: bool,
+    global_alignment: bool,
+):
+    """
+    JiWER is a python tool for computing the word-error-rate of ASR systems. To use
+    this CLI, store the reference and hypothesis sentences in a text file, where
+    each sentence is delimited by a new-line character.
+    The text files are expected to have an equal number of lines, unless the `-g` flag
+    is used. The `-g` flag joins computation of the WER by doing a global minimal
+    alignment.
+
+    """
+    with reference_file.open("r") as f:
+        reference_sentences = [
+            ln.strip() for ln in f.readlines() if len(ln.strip()) > 1
+        ]
+
+    with hypothesis_file.open("r") as f:
+        hypothesis_sentences = [
+            ln.strip() for ln in f.readlines() if len(ln.strip()) > 1
+        ]
+
+    if not global_alignment and len(reference_sentences) != len(hypothesis_sentences):
+        raise ValueError(
+            f"Number of sentences does not match. "
+            f"{reference_file} contains {len(reference_sentences)} lines."
+            f"{hypothesis_file} contains {len(hypothesis_sentences)} lines."
+        )
+
+    if global_alignment and compute_cer:
+        raise ValueError("--global and --cer are mutually exclusive.")
+
+    if compute_cer:
+        out = jiwer.process_characters(
+            reference_sentences,
+            hypothesis_sentences,
+        )
+    else:
+        if global_alignment:
+            out = jiwer.process_words(
+                reference_sentences,
+                hypothesis_sentences,
+                reference_transform=jiwer.wer_contiguous,
+                hypothesis_transform=jiwer.wer_contiguous,
+            )
+        else:
+            out = jiwer.process_words(reference_sentences, hypothesis_sentences)
+
+    if show_alignment:
+        print(jiwer.visualize_alignment(out, show_measures=True))
+    else:
+        if compute_cer:
+            print(out.cer)
+        else:
+            print(out.wer)
+
+
+if __name__ == "__main__":
+    cli()

jiwer/jiwer/measures.py

@@ -0,0 +1,488 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+Convenience methods for calculating a number of similarity error
+measures between a reference and hypothesis sentence.
+These measures are
+commonly used to measure the performance for an automatic speech recognition
+(ASR) system.
+
+The following measures are implemented:
+
+- Word Error Rate (WER), which is where this library got its name from. This
+  has long been (and arguably still is) the de facto standard for computing
+  ASR performance.
+- Match Error Rate (MER)
+- Word Information Lost (WIL)
+- Word Information Preserved (WIP)
+- Character Error Rate (CER)
+
+Note that these functions merely call
+[jiwer.process_words][process.process_words] and
+[jiwer.process_characters][process.process_characters].
+It is more efficient to call `process_words` or `process_characters` and access the
+results from the
+[jiwer.WordOutput][process.WordOutput] and
+[jiwer.CharacterOutput][process.CharacterOutput]
+classes.
+"""
+import warnings
+
+from typing import List, Union, Dict, Any
+
+from jiwer import transforms as tr
+from jiwer.transformations import wer_default, cer_default
+from jiwer.process import process_words, process_words_embdiff, process_characters
+
+__all__ = [
+    "wer",
+    "wer_embdiff",
+    "mer",
+    "wil",
+    "wip",
+    "cer",
+    "compute_measures",
+]
+
+########################################################################################
+# Implementation of the WER method and co, exposed publicly
+
+
+def wer(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> float:
+    """
+    Calculate the word error rate (WER) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+         `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The word error rate of the given reference and
+                 hypothesis sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output = process_words(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+    return output.wer
+
+def wer_embdiff(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> float:
+    """
+    Calculate the word error rate (WER) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+         `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The word error rate of the given reference and
+                 hypothesis sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output, edit_ops = process_words_embdiff(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+    return output, edit_ops
+
+
+def mer(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> float:
+    """
+    Calculate the match error rate (MER) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+         `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The match error rate of the given reference and
+                 hypothesis sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output = process_words(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+
+    return output.mer
+
+
+def wip(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> float:
+    """
+    Calculate the word information preserved (WIP) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+         `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The word information preserved of the given reference and
+                 hypothesis sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output = process_words(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+
+    return output.wip
+
+
+def wil(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> float:
+    """
+    Calculate the word information lost (WIL) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+        `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The word information lost of the given reference and
+                 hypothesis sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output = process_words(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+
+    return output.wil
+
+
+########################################################################################
+# deprecated method 'compute_measures'
+
+
+def compute_measures(
+    truth: Union[str, List[str]],
+    hypothesis: Union[str, List[str]],
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+) -> Dict[str, Any]:
+    """
+    Efficiently computes all measures using only one function call.
+
+    Deprecated:
+        Deprecated method. Superseded by [jiwer.process_words][process.process_words].
+        This method will be removed on next release.
+
+    Args:
+        truth: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        truth_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+
+    Returns:
+        (dict): A dictionary containing key-value pairs for all measures.
+
+    """
+    warnings.warn(
+        DeprecationWarning(
+            "jiwer.compute_measures() is deprecated. Please use jiwer.process_words()."
+        )
+    )
+
+    output = process_words(
+        reference=truth,
+        hypothesis=hypothesis,
+        reference_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    return {
+        "wer": output.wer,
+        "mer": output.mer,
+        "wil": output.wil,
+        "wip": output.wip,
+        "hits": output.hits,
+        "substitutions": output.substitutions,
+        "deletions": output.deletions,
+        "insertions": output.insertions,
+        "ops": output.alignments,
+        "truth": output.references,
+        "hypothesis": output.hypotheses,
+    }
+
+
+########################################################################################
+# Implementation of character-error-rate, exposed publicly
+
+
+def cer(
+    reference: Union[str, List[str]] = None,
+    hypothesis: Union[str, List[str]] = None,
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = cer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = cer_default,
+    return_dict: bool = False,
+    truth: Union[str, List[str]] = None,
+    truth_transform: Union[tr.Compose, tr.AbstractTransform] = None,
+) -> Union[float, Dict[str, Any]]:
+    """
+    Calculate the character error rate (CER) between one or more reference and
+    hypothesis sentences.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+        return_dict: Deprecated option to return the more results in a dict instead of
+                     returning only the cer as a single float value
+        truth: Deprecated, renamed to `reference`
+        truth_transform: Deprecated, renamed to `reference_transform`
+
+    Deprecated:
+        Argument `return_dict` will be deprecated. Please use
+        [jiwer.process_characters][process.process_characters] instead.
+
+        Arguments `truth` and `truth_transform` have been renamed to respectively
+        `reference` and `reference_transform`. Therefore, the keyword arguments
+         `truth` and `truth_transform` will be removed in the next release.
+         At the same time, `reference` and `reference_transform` will lose their
+         default value.
+
+    Returns:
+        (float): The character error rate of the given reference and hypothesis
+                 sentence(s).
+    """
+    (
+        reference,
+        hypothesis,
+        reference_transform,
+        hypothesis_transform,
+    ) = _deprecate_truth(
+        reference=reference,
+        hypothesis=hypothesis,
+        truth=truth,
+        reference_transform=reference_transform,
+        truth_transform=truth_transform,
+        hypothesis_transform=hypothesis_transform,
+    )
+
+    output = process_characters(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+
+    if return_dict:
+        warnings.warn(
+            DeprecationWarning(
+                "`return_dict` is deprecated, "
+                "please use jiwer.process_characters() instead."
+            )
+        )
+        return {
+            "cer": output.cer,
+            "hits": output.hits,
+            "substitutions": output.substitutions,
+            "deletions": output.deletions,
+            "insertions": output.insertions,
+        }
+    else:
+        return output.cer
+
+
+def _deprecate_truth(
+    reference: Union[str, List[str]],
+    hypothesis: Union[str, List[str]],
+    truth: Union[str, List[str]],
+    reference_transform: Union[tr.Compose, tr.AbstractTransform],
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform],
+    truth_transform: Union[tr.Compose, tr.AbstractTransform],
+):
+    if truth is not None:
+        warnings.warn(
+            DeprecationWarning(
+                "keyword argument `truth` is deprecated, please use `reference`."
+            )
+        )
+        if reference is not None:
+            raise ValueError("cannot give `reference` and `truth`")
+        reference = truth
+    if truth_transform is not None:
+        warnings.warn(
+            DeprecationWarning(
+                "keyword argument `truth_transform` is deprecated, "
+                "please use `reference_transform`."
+            )
+        )
+        reference_transform = truth_transform
+
+    if reference is None or hypothesis is None:
+        raise ValueError(
+            "detected default values for reference or hypothesis arguments, "
+            "please provide actual string or list of strings"
+        )
+
+    return reference, hypothesis, reference_transform, hypothesis_transform

jiwer/jiwer/process.py

@@ -0,0 +1,525 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+The core algorithm(s) for processing a one or more reference and hypothesis sentences
+so that measures can be computed and an alignment can be visualized.
+"""
+
+from dataclasses import dataclass
+
+from typing import Any, List, Union
+from itertools import chain
+
+import rapidfuzz
+
+from rapidfuzz.distance import Opcodes
+
+from jiwer import transforms as tr
+from jiwer.transformations import wer_default, cer_default
+
+
+__all__ = [
+    "AlignmentChunk",
+    "WordOutput",
+    "CharacterOutput",
+    "process_words",
+    "process_words_embdiff",
+    "process_characters",
+]
+
+
+@dataclass
+class AlignmentChunk:
+    """
+    Define an alignment between two subsequence of the reference and hypothesis.
+
+    Attributes:
+        type: one of `equal`, `substitute`, `insert`, or `delete`
+        ref_start_idx: the start index of the reference subsequence
+        ref_end_idx: the end index of the reference subsequence
+        hyp_start_idx: the start index of the hypothesis subsequence
+        hyp_end_idx: the end index of the hypothesis subsequence
+    """
+
+    type: str
+
+    ref_start_idx: int
+    ref_end_idx: int
+
+    hyp_start_idx: int
+    hyp_end_idx: int
+
+    def __post_init__(self):
+        if self.type not in ["replace", "insert", "delete", "equal", "substitute"]:
+            raise ValueError("")
+
+        # rapidfuzz uses replace instead of substitute... For consistency, we change it
+        if self.type == "replace":
+            self.type = "substitute"
+
+        if self.ref_start_idx > self.ref_end_idx:
+            raise ValueError(
+                f"ref_start_idx={self.ref_start_idx} "
+                f"is larger "
+                f"than ref_end_idx={self.ref_end_idx}"
+            )
+        if self.hyp_start_idx > self.hyp_end_idx:
+            raise ValueError(
+                f"hyp_start_idx={self.hyp_start_idx} "
+                f"is larger "
+                f"than hyp_end_idx={self.hyp_end_idx}"
+            )
+
+
+@dataclass
+class WordOutput:
+    """
+    The output of calculating the word-level levenshtein distance between one or more
+    reference and hypothesis sentence(s).
+
+    Attributes:
+        references: The reference sentences
+        hypotheses: The hypothesis sentences
+        alignments: The alignment between reference and hypothesis sentences
+        wer: The word error rate
+        mer: The match error rate
+        wil: The word information lost measure
+        wip: The word information preserved measure
+        hits: The number of correct words between reference and hypothesis sentences
+        substitutions: The number of substitutions required to transform hypothesis
+                       sentences to reference sentences
+        insertions: The number of insertions required to transform hypothesis
+                       sentences to reference sentences
+        deletions: The number of deletions required to transform hypothesis
+                       sentences to reference sentences
+
+    """
+
+    # processed input data
+    references: List[List[str]]
+    hypotheses: List[List[str]]
+
+    # alignment
+    alignments: List[List[AlignmentChunk]]
+
+    # measures
+    wer: float
+    mer: float
+    wil: float
+    wip: float
+
+    # stats
+    hits: int
+    substitutions: int
+    insertions: int
+    deletions: int
+
+
+def process_words(
+    reference: Union[str, List[str]],
+    hypothesis: Union[str, List[str]],
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+) -> WordOutput:
+    """
+    Compute the word-level levenshtein distance and alignment between one or more
+    reference and hypothesis sentences. Based on the result, multiple measures
+    can be computed, such as the word error rate.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+
+    Returns:
+        (WordOutput): The processed reference and hypothesis sentences
+    """
+    # validate input type
+    if isinstance(reference, str):
+        reference = [reference]
+    if isinstance(hypothesis, str):
+        hypothesis = [hypothesis]
+    if any(len(t) == 0 for t in reference):
+        raise ValueError("one or more references are empty strings")
+
+    # pre-process reference and hypothesis by applying transforms
+    ref_transformed = _apply_transform(
+        reference, reference_transform, is_reference=True
+    )
+    hyp_transformed = _apply_transform(
+        hypothesis, hypothesis_transform, is_reference=False
+    )
+
+    if len(ref_transformed) != len(hyp_transformed):
+        raise ValueError(
+            "After applying the transforms on the reference and hypothesis sentences, "
+            f"their lengths must match. "
+            f"Instead got {len(ref_transformed)} reference and "
+            f"{len(hyp_transformed)} hypothesis sentences."
+        )
+
+    # Change each word into a unique character in order to compute
+    # word-level levenshtein distance
+    ref_as_chars, hyp_as_chars = _word2char(ref_transformed, hyp_transformed)
+
+    # keep track of total hits, substitutions, deletions and insertions
+    # across all input sentences
+    num_hits, num_substitutions, num_deletions, num_insertions = 0, 0, 0, 0
+
+    # also keep track of the total number of words in the reference and hypothesis
+    num_rf_words, num_hp_words = 0, 0
+
+    # anf finally, keep track of the alignment between each reference and hypothesis
+    alignments = []
+
+    for reference_sentence, hypothesis_sentence in zip(ref_as_chars, hyp_as_chars):
+        # Get the required edit operations to transform reference into hypothesis
+        edit_ops = rapidfuzz.distance.Levenshtein.editops(
+            reference_sentence, hypothesis_sentence
+        )
+
+        # count the number of edits of each type
+        substitutions = sum(1 if op.tag == "replace" else 0 for op in edit_ops)
+        deletions = sum(1 if op.tag == "delete" else 0 for op in edit_ops)
+        insertions = sum(1 if op.tag == "insert" else 0 for op in edit_ops)
+        hits = len(reference_sentence) - (substitutions + deletions)
+
+        # update state
+        num_hits += hits
+        num_substitutions += substitutions
+        num_deletions += deletions
+        num_insertions += insertions
+        num_rf_words += len(reference_sentence)
+        num_hp_words += len(hypothesis_sentence)
+        alignments.append(
+            [
+                AlignmentChunk(
+                    type=op.tag,
+                    ref_start_idx=op.src_start,
+                    ref_end_idx=op.src_end,
+                    hyp_start_idx=op.dest_start,
+                    hyp_end_idx=op.dest_end,
+                )
+                for op in Opcodes.from_editops(edit_ops)
+            ]
+        )
+
+    # Compute all measures
+    S, D, I, H = num_substitutions, num_deletions, num_insertions, num_hits
+
+    wer = float(S + D + I) / float(H + S + D)
+    mer = float(S + D + I) / float(H + S + D + I)
+    wip = (
+        (float(H) / num_rf_words) * (float(H) / num_hp_words)
+        if num_hp_words >= 1
+        else 0
+    )
+    wil = 1 - wip
+
+    # return all output
+    return WordOutput(
+        references=ref_transformed,
+        hypotheses=hyp_transformed,
+        alignments=alignments,
+        wer=wer,
+        mer=mer,
+        wil=wil,
+        wip=wip,
+        hits=num_hits,
+        substitutions=num_substitutions,
+        insertions=num_insertions,
+        deletions=num_deletions,
+    )
+
+def process_words_embdiff(
+    reference: Union[str, List[str]],
+    hypothesis: Union[str, List[str]],
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = wer_default,
+) -> WordOutput:
+    """
+    Compute the word-level levenshtein distance and alignment between one or more
+    reference and hypothesis sentences. Based on the result, multiple measures
+    can be computed, such as the word error rate.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+
+    Returns:
+        (WordOutput): The processed reference and hypothesis sentences
+    """
+    # validate input type
+    if isinstance(reference, str):
+        reference = [reference]
+    if isinstance(hypothesis, str):
+        hypothesis = [hypothesis]
+    if any(len(t) == 0 for t in reference):
+        raise ValueError("one or more references are empty strings")
+
+    # pre-process reference and hypothesis by applying transforms
+    ref_transformed = _apply_transform(
+        reference, reference_transform, is_reference=True
+    )
+    hyp_transformed = _apply_transform(
+        hypothesis, hypothesis_transform, is_reference=False
+    )
+
+    if len(ref_transformed) != len(hyp_transformed):
+        raise ValueError(
+            "After applying the transforms on the reference and hypothesis sentences, "
+            f"their lengths must match. "
+            f"Instead got {len(ref_transformed)} reference and "
+            f"{len(hyp_transformed)} hypothesis sentences."
+        )
+
+    # Change each word into a unique character in order to compute
+    # word-level levenshtein distance
+    ref_as_chars, hyp_as_chars = _word2char(ref_transformed, hyp_transformed)
+
+    # keep track of total hits, substitutions, deletions and insertions
+    # across all input sentences
+    num_hits, num_substitutions, num_deletions, num_insertions = 0, 0, 0, 0
+
+    # also keep track of the total number of words in the reference and hypothesis
+    num_rf_words, num_hp_words = 0, 0
+
+    # anf finally, keep track of the alignment between each reference and hypothesis
+    alignments = []
+
+    for reference_sentence, hypothesis_sentence in zip(ref_as_chars, hyp_as_chars):
+        # Get the required edit operations to transform reference into hypothesis
+        edit_ops = rapidfuzz.distance.Levenshtein.editops(
+            reference_sentence, hypothesis_sentence
+        )
+
+        # count the number of edits of each type
+        substitutions = sum(1 if op.tag == "replace" else 0 for op in edit_ops)
+        deletions = sum(1 if op.tag == "delete" else 0 for op in edit_ops)
+        insertions = sum(1 if op.tag == "insert" else 0 for op in edit_ops)
+        hits = len(reference_sentence) - (substitutions + deletions)
+
+        # update state
+        num_hits += hits
+        num_substitutions += substitutions
+        num_deletions += deletions
+        num_insertions += insertions
+        num_rf_words += len(reference_sentence)
+        num_hp_words += len(hypothesis_sentence)
+        alignments.append(
+            [
+                AlignmentChunk(
+                    type=op.tag,
+                    ref_start_idx=op.src_start,
+                    ref_end_idx=op.src_end,
+                    hyp_start_idx=op.dest_start,
+                    hyp_end_idx=op.dest_end,
+                )
+                for op in Opcodes.from_editops(edit_ops)
+            ]
+        )
+
+    # Compute all measures
+    S, D, I, H = num_substitutions, num_deletions, num_insertions, num_hits
+
+    wer = float(S + D + I) / float(H + S + D)
+    mer = float(S + D + I) / float(H + S + D + I)
+    wip = (
+        (float(H) / num_rf_words) * (float(H) / num_hp_words)
+        if num_hp_words >= 1
+        else 0
+    )
+    wil = 1 - wip
+
+    # return all output
+    return WordOutput(
+        references=ref_transformed,
+        hypotheses=hyp_transformed,
+        alignments=alignments,
+        wer=wer,
+        mer=mer,
+        wil=wil,
+        wip=wip,
+        hits=num_hits,
+        substitutions=num_substitutions,
+        insertions=num_insertions,
+        deletions=num_deletions,
+    ), edit_ops
+
+
+########################################################################################
+# Implementation of character error rate
+
+
+@dataclass
+class CharacterOutput:
+    """
+    The output of calculating the character-level levenshtein distance between one or
+    more reference and hypothesis sentence(s).
+
+    Attributes:
+        references: The reference sentences
+        hypotheses: The hypothesis sentences
+        alignments: The alignment between reference and hypothesis sentences
+        cer: The character error rate
+        hits: The number of correct characters between reference and hypothesis
+              sentences
+        substitutions: The number of substitutions required to transform hypothesis
+                       sentences to reference sentences
+        insertions: The number of insertions required to transform hypothesis
+                       sentences to reference sentences
+        deletions: The number of deletions required to transform hypothesis
+                       sentences to reference sentences
+    """
+
+    # processed input data
+    references: List[List[str]]
+    hypotheses: List[List[str]]
+
+    # alignment
+    alignments: List[List[AlignmentChunk]]
+
+    # measures
+    cer: float
+
+    # stats
+    hits: int
+    substitutions: int
+    insertions: int
+    deletions: int
+
+
+def process_characters(
+    reference: Union[str, List[str]],
+    hypothesis: Union[str, List[str]],
+    reference_transform: Union[tr.Compose, tr.AbstractTransform] = cer_default,
+    hypothesis_transform: Union[tr.Compose, tr.AbstractTransform] = cer_default,
+) -> CharacterOutput:
+    """
+    Compute the character-level levenshtein distance and alignment between one or more
+    reference and hypothesis sentences. Based on the result, the character error rate
+    can be computed.
+
+    Note that the by default this method includes space (` `) as a
+    character over which the error rate is computed. If this is not desired, the
+    reference and hypothesis transform need to be modified.
+
+    Args:
+        reference: The reference sentence(s)
+        hypothesis: The hypothesis sentence(s)
+        reference_transform: The transformation(s) to apply to the reference string(s)
+        hypothesis_transform: The transformation(s) to apply to the hypothesis string(s)
+
+    Returns:
+        (CharacterOutput): The processed reference and hypothesis sentences.
+
+    """
+    # make sure the transforms end with tr.ReduceToListOfListOfChars(),
+
+    # it's the same as word processing, just every word is of length 1
+    result = process_words(
+        reference, hypothesis, reference_transform, hypothesis_transform
+    )
+
+    return CharacterOutput(
+        references=result.references,
+        hypotheses=result.hypotheses,
+        alignments=result.alignments,
+        cer=result.wer,
+        hits=result.hits,
+        substitutions=result.substitutions,
+        insertions=result.insertions,
+        deletions=result.deletions,
+    )
+
+
+################################################################################
+# Implementation of helper methods
+
+
+def _apply_transform(
+    sentence: Union[str, List[str]],
+    transform: Union[tr.Compose, tr.AbstractTransform],
+    is_reference: bool,
+):
+    # Apply transforms. The transforms should collapse input to a
+    # list with lists of words
+    transformed_sentence = transform(sentence)
+
+    # Validate the output is a list containing lists of strings
+    if is_reference:
+        if not _is_list_of_list_of_strings(
+            transformed_sentence, require_non_empty_lists=True
+        ):
+            raise ValueError(
+                "After applying the transformation, each reference should be a "
+                "non-empty list of strings, with each string being a single word."
+            )
+    else:
+        if not _is_list_of_list_of_strings(
+            transformed_sentence, require_non_empty_lists=False
+        ):
+            raise ValueError(
+                "After applying the transformation, each hypothesis should be a "
+                "list of strings, with each string being a single word."
+            )
+
+    return transformed_sentence
+
+
+def _is_list_of_list_of_strings(x: Any, require_non_empty_lists: bool):
+    if not isinstance(x, list):
+        return False
+
+    for e in x:
+        if not isinstance(e, list):
+            return False
+
+        if require_non_empty_lists and len(e) == 0:
+            return False
+
+        if not all([isinstance(s, str) for s in e]):
+            return False
+
+    return True
+
+
+def _word2char(reference: List[List[str]], hypothesis: List[List[str]]):
+    # tokenize each word into an integer
+    vocabulary = set(chain(*reference, *hypothesis))
+
+    if "" in vocabulary:
+        raise ValueError(
+            "Empty strings cannot be a word. "
+            "Please ensure that the given transform removes empty strings."
+        )
+
+    word2char = dict(zip(vocabulary, range(len(vocabulary))))
+
+    reference_chars = [
+        "".join([chr(word2char[w]) for w in sentence]) for sentence in reference
+    ]
+    hypothesis_chars = [
+        "".join([chr(word2char[w]) for w in sentence]) for sentence in hypothesis
+    ]
+
+    return reference_chars, hypothesis_chars

jiwer/jiwer/transformations.py

@@ -0,0 +1,128 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This file is intended to provide the default transformation which need
+to be applied to input text in order to compute the WER (or similar measures).
+
+It also implements some alternative transformations which might be
+useful in specific use cases.
+"""
+
+import jiwer.transforms as tr
+
+__all__ = [
+    "wer_default",
+    "wer_contiguous",
+    "wer_standardize",
+    "wer_standardize_contiguous",
+    "cer_default",
+    "cer_contiguous",
+]
+
+########################################################################################
+# implement transformations for WER (and accompanying measures)
+
+wer_default = tr.Compose(
+    [
+        tr.RemoveMultipleSpaces(),
+        tr.Strip(),
+        tr.ReduceToListOfListOfWords(),
+    ]
+)
+"""
+This is the default transformation when using `proces_words`. Each input string will 
+have its leading and tailing white space removed. 
+Thereafter multiple spaces between words are also removed. 
+Then each string is transformed into a list with lists of strings, where each string
+is a single word.
+"""
+
+wer_contiguous = tr.Compose(
+    [
+        tr.RemoveMultipleSpaces(),
+        tr.Strip(),
+        tr.ReduceToSingleSentence(),
+        tr.ReduceToListOfListOfWords(),
+    ]
+)
+"""
+This is can be used instead of `wer_default` when the number of reference and hypothesis 
+sentences differ. 
+"""
+
+wer_standardize = tr.Compose(
+    [
+        tr.ToLowerCase(),
+        tr.ExpandCommonEnglishContractions(),
+        tr.RemoveKaldiNonWords(),
+        tr.RemoveWhiteSpace(replace_by_space=True),
+        tr.RemoveMultipleSpaces(),
+        tr.Strip(),
+        tr.ReduceToListOfListOfWords(),
+    ]
+)
+"""
+This transform attempts to standardize the strings by setting all characters to lower
+case, expanding common contractions, and removing non-words. Then the default operations
+are applied.  
+"""
+
+wer_standardize_contiguous = tr.Compose(
+    [
+        tr.ToLowerCase(),
+        tr.ExpandCommonEnglishContractions(),
+        tr.RemoveKaldiNonWords(),
+        tr.RemoveWhiteSpace(replace_by_space=True),
+        tr.RemoveMultipleSpaces(),
+        tr.Strip(),
+        tr.ReduceToSingleSentence(),
+        tr.ReduceToListOfListOfWords(),
+    ]
+)
+"""
+This is the same as `wer_standize`, but this version can be usd when the number of
+reference and hypothesis sentences differ. 
+"""
+
+########################################################################################
+# implement transformations for CER
+
+
+cer_default = tr.Compose(
+    [
+        tr.Strip(),
+        tr.ReduceToListOfListOfChars(),
+    ]
+)
+"""
+This is the default transformation when using `process_characters`. Each input string
+will  have its leading and tailing white space removed. Then each string is 
+transformed into a list with lists of strings, where each string is a single character. 
+"""
+
+cer_contiguous = tr.Compose(
+    [
+        tr.Strip(),
+        tr.ReduceToSingleSentence(),
+        tr.ReduceToListOfListOfChars(),
+    ]
+)
+"""
+This can used instead of `cer_default` when the number of reference and hypothesis 
+sentences differ.
+"""

jiwer/jiwer/transforms.py

@@ -0,0 +1,620 @@
+#
+# JiWER - Jitsi Word Error Rate
+#
+# Copyright @ 2018 - present 8x8, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+This file implements the building blocks for transforming a collection
+of input strings to the desired format in order to calculate the WER of CER.
+
+In principle, for word error rate calculations, every string of a sentence needs to be
+collapsed into a list of strings, where each string is a *single* word.
+This is done with [transforms.ReduceToListOfListOfWords][].
+A composition of multiple transformations must therefore *always* end with
+[transforms.ReduceToListOfListOfWords][].
+
+For the character error rate, every string of a sentence also needs to be collapsed into
+a list of strings, but here each string is a *single* character.
+This is done with [transforms.ReduceToListOfListOfChars][]. Similarly, a
+composition of multiple transformations must therefore also always end with
+[transforms.ReduceToListOfListOfChars][].
+"""
+
+import sys
+import functools
+import re
+import string
+import unicodedata
+
+from typing import Union, List, Mapping
+
+
+__all__ = [
+    "AbstractTransform",
+    "Compose",
+    "ExpandCommonEnglishContractions",
+    "RemoveEmptyStrings",
+    "ReduceToListOfListOfWords",
+    "ReduceToListOfListOfChars",
+    "ReduceToSingleSentence",
+    "RemoveKaldiNonWords",
+    "RemoveMultipleSpaces",
+    "RemovePunctuation",
+    "RemoveSpecificWords",
+    "RemoveWhiteSpace",
+    "Strip",
+    "SubstituteRegexes",
+    "SubstituteWords",
+    "ToLowerCase",
+    "ToUpperCase",
+]
+
+
+class AbstractTransform(object):
+    """
+    The base class of a Transform.
+    """
+
+    def __call__(self, sentences: Union[str, List[str]]):
+        """
+        Transforms one or more strings.
+
+        Args:
+            sentences: The strings to transform.
+
+        Returns:
+            (Union[str, List[str]]): The transformed strings.
+
+        """
+        if isinstance(sentences, str):
+            return self.process_string(sentences)
+        elif isinstance(sentences, list):
+            return self.process_list(sentences)
+        else:
+            raise ValueError(
+                "input {} was expected to be a string or list of strings".format(
+                    sentences
+                )
+            )
+
+    def process_string(self, s: str):
+        raise NotImplementedError()
+
+    def process_list(self, inp: List[str]):
+        return [self.process_string(s) for s in inp]
+
+
+class Compose(object):
+    """
+    Chain multiple transformations back-to-back to create a pipeline combining multiple
+    transformations.
+
+    Note that each transformation needs to end with either `ReduceToListOfListOfWords`
+    or `ReduceToListOfListOfChars`, depending on whether word error rate,
+    or character error rate is desired.
+
+    Example:
+        ```python3
+        import jiwer
+
+        jiwer.Compose([
+            jiwer.RemoveMultipleSpaces(),
+            jiwer.ReduceToListOfListOfWords()
+        ])
+        ```
+    """
+
+    def __init__(self, transforms: List[AbstractTransform]):
+        """
+
+        Args:
+            transforms: The list of transformations to chain.
+        """
+        self.transforms = transforms
+
+    def __call__(self, text):
+        for tr in self.transforms:
+            text = tr(text)
+
+        return text
+
+
+class BaseRemoveTransform(AbstractTransform):
+    def __init__(self, tokens_to_remove: List[str], replace_token=""):
+        self.tokens_to_remove = tokens_to_remove
+        self.replace_token = replace_token
+
+    def process_string(self, s: str):
+        for w in self.tokens_to_remove:
+            s = s.replace(w, self.replace_token)
+
+        return s
+
+    def process_list(self, inp: List[str]):
+        return [self.process_string(s) for s in inp]
+
+
+class ReduceToListOfListOfWords(AbstractTransform):
+    """
+    Transforms a single input sentence, or a list of input sentences, into
+    a list with lists of words, which is the expected format for calculating the
+    edit operations between two input sentences on a word-level.
+
+    A sentence is assumed to be a string, where words are delimited by a token
+    (such as ` `, space). Each string is expected to contain only a single sentence.
+    Empty strings (no output) are removed for the list.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["hi", "this is an example"]
+
+        print(jiwer.ReduceToListOfListOfWords()(sentences))
+        # prints: [['hi'], ['this', 'is', 'an, 'example']]
+        ```
+    """
+
+    def __init__(self, word_delimiter: str = " "):
+        """
+        Args:
+            word_delimiter: the character which delimits words. Default is ` ` (space).
+        """
+        self.word_delimiter = word_delimiter
+
+    def process_string(self, s: str):
+        return [[w for w in s.split(self.word_delimiter) if len(w) >= 1]]
+
+    def process_list(self, inp: List[str]):
+        sentence_collection = []
+
+        for sentence in inp:
+            list_of_words = self.process_string(sentence)[0]
+
+            sentence_collection.append(list_of_words)
+
+        if len(sentence_collection) == 0:
+            return [[]]
+
+        return sentence_collection
+
+
+class ReduceToListOfListOfChars(AbstractTransform):
+    """
+    Transforms a single input sentence, or a list of input sentences, into
+    a list with lists of characters, which is the expected format for calculating the
+    edit operations between two input sentences on a character-level.
+
+    A sentence is assumed to be a string. Each string is expected to contain only a
+    single sentence.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["hi", "this is an example"]
+
+        print(jiwer.ReduceToListOfListOfChars()(sentences))
+        # prints: [['h', 'i'], ['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', 'n', ' ', 'e', 'x', 'a', 'm', 'p', 'l', 'e']]
+        ```
+    """
+
+    def process_string(self, s: str):
+        return [[w for w in s]]
+
+    def process_list(self, inp: List[str]):
+        sentence_collection = []
+
+        for sentence in inp:
+            list_of_words = self.process_string(sentence)[0]
+
+            sentence_collection.append(list_of_words)
+
+        if len(sentence_collection) == 0:
+            return [[]]
+
+        return sentence_collection
+
+
+class ReduceToSingleSentence(AbstractTransform):
+    """
+    Transforms multiple sentences into a single sentence.
+    This operation can be useful when the number of reference and hypothesis sentences
+    differ, and you want to do a minimal alignment over these lists.
+    Note that this creates an invariance: `wer([a, b], [a, b])` might not be equal to
+    `wer([b, a], [b, a])`.
+
+    Example:
+        ```python3
+        import jiwer
+
+        sentences = ["hi", "this is an example"]
+
+        print(jiwer.ReduceToSingleSentence()(sentences))
+        # prints: ['hi this is an example']
+        ```
+    """
+
+    def __init__(self, word_delimiter: str = " "):
+        """
+        :param word_delimiter: the character which delimits words. Default is ` ` (space).
+        """
+        self.word_delimiter = word_delimiter
+
+    def process_string(self, s: str):
+        return s
+
+    def process_list(self, inp: List[str]):
+        filtered_inp = [i for i in inp if len(i) >= 1]
+
+        if len(filtered_inp) == 0:
+            return []
+        else:
+            return ["{}".format(self.word_delimiter).join(filtered_inp)]
+
+
+class SubstituteRegexes(AbstractTransform):
+    """
+    Transform strings by substituting substrings matching regex expressions into
+    another substring.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["is the world doomed or loved?", "edibles are allegedly cultivated"]
+
+        # note: the regex string "\b(\w+)ed\b", matches every word ending in 'ed',
+        # and "\1" stands for the first group ('\w+). It therefore removes 'ed' in every match.
+        print(jiwer.SubstituteRegexes({r"doom": r"sacr", r"\b(\w+)ed\b": r"\1"})(sentences))
+
+        # prints: ["is the world sacr or lov?", "edibles are allegedly cultivat"]
+        ```
+    """
+
+    def __init__(self, substitutions: Mapping[str, str]):
+        """
+
+        Args:
+            substitutions: a mapping of regex expressions to replacement strings.
+        """
+        self.substitutions = substitutions
+
+    def process_string(self, s: str):
+        for key, value in self.substitutions.items():
+            s = re.sub(key, value, s)
+
+        return s
+
+
+class SubstituteWords(AbstractTransform):
+    """
+    This transform can be used to replace a word into another word.
+    Note that the whole word is matched. If the word you're attempting to substitute
+    is a substring of another word it will not be affected.
+    For example, if you're substituting `foo` into `bar`, the word `foobar` will NOT
+    be substituted into `barbar`.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["you're pretty", "your book", "foobar"]
+
+        print(jiwer.SubstituteWords({"pretty": "awesome", "you": "i", "'re": " am", 'foo': 'bar'})(sentences))
+
+        # prints: ["i am awesome", "your book", "foobar"]
+        ```
+
+    """
+
+    def __init__(self, substitutions: Mapping[str, str]):
+        """
+        Args:
+            substitutions: A mapping of words to replacement words.
+        """
+        self.substitutions = substitutions
+
+    def process_string(self, s: str):
+        for key, value in self.substitutions.items():
+            s = re.sub(r"\b{}\b".format(re.escape(key)), value, s)
+
+        return s
+
+
+class RemoveSpecificWords(SubstituteWords):
+    """
+    Can be used to filter out certain words.
+    As words are replaced with a ` ` character, make sure to that
+    `RemoveMultipleSpaces`, `Strip()` and `RemoveEmptyStrings` are present
+    in the composition _after_ `RemoveSpecificWords`.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["yhe awesome", "the apple is not a pear", "yhe"]
+
+        print(jiwer.RemoveSpecificWords(["yhe", "the", "a"])(sentences))
+        # prints: ['  awesome', '  apple is not   pear', ' ']
+        # note the extra spaces
+        ```
+    """
+
+    def __init__(self, words_to_remove: List[str]):
+        """
+        Args:
+            words_to_remove: List of words to remove.
+        """
+        mapping = {word: " " for word in words_to_remove}
+
+        super().__init__(mapping)
+
+
+class RemoveWhiteSpace(BaseRemoveTransform):
+    """
+    This transform filters out white space characters.
+    Note that by default space (` `) is also removed, which will make it impossible to
+    split a sentence into a list of words by using `ReduceToListOfListOfWords` or
+    `ReduceToSingleSentence`.
+    This can be prevented by replacing all whitespace with the space character.
+    If so, make sure that `jiwer.RemoveMultipleSpaces`,
+    `Strip()` and `RemoveEmptyStrings` are present in the composition _after_
+    `RemoveWhiteSpace`.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["this is an example", "hello world\t"]
+
+        print(jiwer.RemoveWhiteSpace()(sentences))
+        # prints: ["thisisanexample", "helloworld"]
+
+        print(jiwer.RemoveWhiteSpace(replace_by_space=True)(sentences))
+        # prints: ["this is an example", "hello world  "]
+        # note the trailing spaces
+        ```
+    """
+
+    def __init__(self, replace_by_space: bool = False):
+        """
+
+        Args:
+            replace_by_space: every white space character is replaced with a space (` `)
+        """
+        characters = [c for c in string.whitespace]
+
+        if replace_by_space:
+            replace_token = " "
+        else:
+            replace_token = ""
+
+        super().__init__(characters, replace_token=replace_token)
+
+
+@functools.lru_cache(1)
+def _get_punctuation_characters():
+    """Compute the punctuation characters only once and memoize."""
+    codepoints = range(sys.maxunicode + 1)
+    punctuation = set(
+        chr(i) for i in codepoints if unicodedata.category(chr(i)).startswith("P")
+    )
+    return punctuation
+
+
+class RemovePunctuation(BaseRemoveTransform):
+    """
+    This transform filters out punctuation. The punctuation characters are defined as
+    all unicode characters whose category name starts with `P`.
+    See [here](https://www.unicode.org/reports/tr44/#General_Category_Values) for more
+    information.
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["this is an example!", "hello. goodbye"]
+
+        print(jiwer.RemovePunctuation()(sentences))
+        # prints: ['this is an example', "hello goodbye"]
+        ```
+    """
+
+    def __init__(self):
+        punctuation_characters = _get_punctuation_characters()
+        super().__init__(punctuation_characters)
+
+
+class RemoveMultipleSpaces(AbstractTransform):
+    """
+    Filter out multiple spaces between words.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["this is   an   example ", "  hello goodbye  ", "  "]
+
+        print(jiwer.RemoveMultipleSpaces()(sentences))
+        # prints: ['this is an example ', " hello goodbye ", " "]
+        # note that there are still trailing spaces
+        ```
+
+    """
+
+    def process_string(self, s: str):
+        return re.sub(r"\s\s+", " ", s)
+
+    def process_list(self, inp: List[str]):
+        return [self.process_string(s) for s in inp]
+
+
+class Strip(AbstractTransform):
+    """
+    Removes all leading and trailing spaces.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = [" this is an example ", "  hello goodbye  ", "  "]
+
+        print(jiwer.Strip()(sentences))
+        # prints: ['this is an example', "hello goodbye", ""]
+        # note that there is an empty string left behind which might need to be cleaned up
+        ```
+    """
+
+    def process_string(self, s: str):
+        return s.strip()
+
+
+class RemoveEmptyStrings(AbstractTransform):
+    """
+    Remove empty strings from a list of strings.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["", "this is an example", " ",  "                "]
+
+        print(jiwer.RemoveEmptyStrings()(sentences))
+        # prints: ['this is an example']
+        ```
+    """
+
+    def process_string(self, s: str):
+        return s.strip()
+
+    def process_list(self, inp: List[str]):
+        return [s for s in inp if self.process_string(s) != ""]
+
+
+class ExpandCommonEnglishContractions(AbstractTransform):
+    """
+    Replace common contractions such as `let's` to `let us`.
+
+    Currently, this method will perform the following replacements. Note that `␣` is
+     used to indicate a space (` `) to get around markdown rendering constrains.
+
+    | Contraction   | transformed into |
+    | ------------- |:----------------:|
+    | `won't`       | `␣will not`      |
+    | `can't`       | `␣can not`       |
+    | `let's`       | `␣let us`        |
+    | `n't`         | `␣not`           |
+    | `'re`         | `␣are`           |
+    | `'s`          | `␣is`            |
+    | `'d`          | `␣would`         |
+    | `'ll`         | `␣will`          |
+    | `'t`          | `␣not`           |
+    | `'ve`         | `␣have`          |
+    | `'m`          | `␣am`            |
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["she'll make sure you can't make it", "let's party!"]
+
+        print(jiwer.ExpandCommonEnglishContractions()(sentences))
+        # prints: ["she will make sure you can not make it", "let us party!"]
+        ```
+
+    """
+
+    def process_string(self, s: str):
+        # definitely a non exhaustive list
+
+        # specific words
+        s = re.sub(r"won't", "will not", s)
+        s = re.sub(r"can\'t", "can not", s)
+        s = re.sub(r"let\'s", "let us", s)
+
+        # general attachments
+        s = re.sub(r"n\'t", " not", s)
+        s = re.sub(r"\'re", " are", s)
+        s = re.sub(r"\'s", " is", s)
+        s = re.sub(r"\'d", " would", s)
+        s = re.sub(r"\'ll", " will", s)
+        s = re.sub(r"\'t", " not", s)
+        s = re.sub(r"\'ve", " have", s)
+        s = re.sub(r"\'m", " am", s)
+
+        return s
+
+
+class ToLowerCase(AbstractTransform):
+    """
+    Convert every character into lowercase.
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["You're PRETTY"]
+
+        print(jiwer.ToLowerCase()(sentences))
+
+        # prints: ["you're pretty"]
+        ```
+    """
+
+    def process_string(self, s: str):
+        return s.lower()
+
+
+class ToUpperCase(AbstractTransform):
+    """
+    Convert every character to uppercase.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["You're amazing"]
+
+        print(jiwer.ToUpperCase()(sentences))
+
+        # prints: ["YOU'RE AMAZING"]
+        ```
+    """
+
+    def process_string(self, s: str):
+        return s.upper()
+
+
+class RemoveKaldiNonWords(AbstractTransform):
+    """
+    Remove any word between `[]` and `<>`. This can be useful when working
+    with hypotheses from the Kaldi project, which can output non-words such as
+    `[laugh]` and `<unk>`.
+
+    Example:
+        ```python
+        import jiwer
+
+        sentences = ["you <unk> like [laugh]"]
+
+        print(jiwer.RemoveKaldiNonWords()(sentences))
+
+        # prints: ["you  like "]
+        # note the extra spaces
+        ```
+    """
+
+    def process_string(self, s: str):
+        return re.sub(r"[<\[][^>\]]*[>\]]", "", s)

jiwer/mkdocs.yml

@@ -0,0 +1,47 @@
+site_name: "jiwer"
+site_description: "Documentation for jiwer."
+site_url: "https://jitsi.github.io/jiwer/"
+repo_url: "https://github.com/jitsi/jiwer"
+edit_uri: "blob/master/docs/"
+repo_name: "jitsi/jiwer"
+site_dir: "site"
+
+theme:
+  name: "material"
+  features:
+    - content.code.annotate
+    - navigation.tabs
+    - navigation.tabs.sticky
+    - navigation.top
+
+plugins:
+- mkdocstrings:
+    handlers:
+      python:
+        paths: [jiwer]
+        options:
+          separate_signature: true
+          show_root_heading: true
+          show_root_members_full_path: false
+- search
+- gen-files:
+    scripts:
+    - docs/gen_ref_pages.py
+- literate-nav:
+    nav_file: SUMMARY.md
+- autorefs
+
+nav:
+  - jiwer: index.md
+  - Usage: usage.md
+  - Command-line interface: cli.md
+  - API reference: reference/
+
+markdown_extensions:
+  - toc:
+      permalink: "#"
+  - pymdownx.superfences
+
+watch:
+- docs
+- jiwer

jiwer/pyproject.toml

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "jiwer"
+version = "3.0.2"
+description = "Evaluate your speech-to-text system with similarity measures such as word error rate (WER)"
+authors = ["Nik Vaessen <[email protected]>"]
+readme = "README.md"
+license = "Apache-2.0"
+repository = "https://github.com/jitsi/jiwer"
+include = ["LICENCE"]
+
+[tool.poetry.dependencies]
+python = "^3.7"
+rapidfuzz = "2.13.7"
+click = "^8.1.3"
+
+[tool.poetry.group.dev.dependencies]
+black = "^22.8.0"
+pytest = "7.1.3"
+pytest-benchmark = "^3.4.1"
+flake8 = "5.0.4"
+
+[tool.poetry.scripts]
+jiwer = "jiwer.cli:cli"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

jiwer/tests/test_alignment.py

@@ -0,0 +1,225 @@
+import unittest
+import jiwer
+
+
+class TestAlignmentVisualizationWords(unittest.TestCase):
+    def test_insertion(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this is a ****\n"
+            "HYP: this is a test\n"
+            "                  I\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words("this is a", "this is a test"), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+        pass
+
+    def test_deletion(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this is a test\n"
+            "HYP: this is a ****\n"
+            "                  D\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words("this is a test", "this is a"), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_substitution(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this  is a test\n"
+            "HYP: this was a test\n"
+            "            S       \n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words("this is a test", "this was a test"),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_all_three(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this  is a ***** test of skill\n"
+            "HYP: this was a messy test ** *****\n"
+            "            S       I       D     D\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words("this is a test of skill", "this was a messy test"),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_show_measures(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this test will have a high word error rate\n"
+            "HYP:   no   it will  not * **** **** ***** ****\n"
+            "        S    S         S D    D    D     D    D\n"
+            "\n"
+            "number of sentences: 1\n"
+            "substitutions=3 deletions=5 insertions=0 hits=1\n"
+            "\n"
+            "mer=88.89%\n"
+            "wil=97.22%\n"
+            "wip=2.78%\n"
+            "wer=88.89%\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words(
+                "this test will  have a high word error rate", "no it will not"
+            ),
+            show_measures=True,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_empty_hypothesis(self):
+        correct_alignment = "sentence 1\n" "REF: empty\n" "HYP: *****\n" "         D\n"
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words("empty", ""), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_multiple_sentences(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: one\n"
+            "HYP:   1\n"
+            "       S\n"
+            "\n"
+            "sentence 2\n"
+            "REF: two\n"
+            "HYP:   2\n"
+            "       S\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words(["one", "two"], ["1", "2"]),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_skip_correct(self):
+        correct_alignment = (
+            "sentence 2\n"
+            "REF: one\n"
+            "HYP:   1\n"
+            "       S\n"
+            "\n"
+            "sentence 3\n"
+            "REF: two\n"
+            "HYP:   2\n"
+            "       S\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_words(
+                ["perfect", "one", "two", "three"], ["perfect", "1", "2", "three"]
+            ),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+
+class TestAlignmentVisualizationCharacters(unittest.TestCase):
+    def test_insertion(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this is a*****\n"
+            "HYP: this is a test\n"
+            "              IIIII\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters("this is a", "this is a test"), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+        pass
+
+    def test_deletion(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this is a test\n"
+            "HYP: this is a*****\n"
+            "              DDDDD\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters("this is a test", "this is a"), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_substitution(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this is a test\n"
+            "HYP: this iz a test\n"
+            "           S       \n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters("this is a test", "this iz a test"),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_all_three(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this *is a tes*t of skill\n"
+            "HYP: this was a messy te*st***\n"
+            "          IS    S  IS SSD SDDD\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters(
+                "this is a test of skill", "this was a messy test"
+            ),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_show_measures(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: this test will  have a high word error rate\n"
+            "HYP: no** i**t will n*************o***********t*\n"
+            "     SSDD SDD       SDDDDDDDDDDDDD DDDDDDDDDDD D\n"
+            "\n"
+            "number of sentences: 1\n"
+            "substitutions=4 deletions=29 insertions=0 hits=10\n"
+            "\n"
+            "cer=76.74%\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters(
+                "this test will  have a high word error rate", "no it will not"
+            ),
+            show_measures=True,
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_empty_hypothesis(self):
+        correct_alignment = "sentence 1\n" "REF: empty\n" "HYP: *****\n" "     DDDDD\n"
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters("empty", ""), show_measures=False
+        )
+        self.assertEqual(alignment, correct_alignment)
+
+    def test_multiple_sentences(self):
+        correct_alignment = (
+            "sentence 1\n"
+            "REF: one\n"
+            "HYP: 1**\n"
+            "     SDD\n"
+            "\n"
+            "sentence 2\n"
+            "REF: two\n"
+            "HYP: 2**\n"
+            "     SDD\n"
+        )
+        alignment = jiwer.visualize_alignment(
+            jiwer.process_characters(["one", "two"], ["1", "2"]),
+            show_measures=False,
+        )
+        self.assertEqual(alignment, correct_alignment)

jiwer/tests/test_cer.py

@@ -0,0 +1,135 @@
+import unittest
+import pytest
+
+import jiwer
+
+from .test_measures import assert_dict_almost_equal
+
+
+class TestCERInputMethods(unittest.TestCase):
+    def test_input_ref_string_hyp_string(self):
+        cases = [
+            ("This is a test", "This is a test", 0 / 14),
+            ("This is a test", "", 14 / 14),
+            ("This is a test", "This test", 5 / 14),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_string_hyp_list(self):
+        cases = [
+            ("This is a test", ["This is a test"], 0 / 14),
+            ("This is a test", [""], 14 / 14),
+            ("This is a test", ["This test"], 5 / 14),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_list_hyp_string(self):
+        cases = [
+            (["This is a test"], "This is a test", 0 / 14),
+            (["This is a test"], "", 14 / 14),
+            (["This is a test"], "This test", 5 / 14),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_list_hyp_list(self):
+        cases = [
+            (["This is a test"], ["This is a test"], 0 / 14),
+            (["This is a test"], [""], 14 / 14),
+            (["This is a test"], ["This test"], 5 / 14),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_fail_on_different_sentence_length(self):
+        def callback():
+            jiwer.cer(["hello", "this", "sentence", "is fractured"], ["this sentence"])
+
+        self.assertRaises(ValueError, callback)
+
+    def test_fail_on_empty_reference(self):
+        def callback():
+            jiwer.cer("", "test")
+
+        self.assertRaises(ValueError, callback)
+
+    def test_known_values(self):
+        # Taken from the "From WER and RIL to MER and WIL" paper, for link see README.md
+        cases = [
+            (
+                "X",
+                "X",
+                0,
+            ),
+            (
+                "X",
+                "X X Y Y",
+                6,
+            ),
+            (
+                "X Y X",
+                "X Z",
+                3 / 5,
+            ),
+            (
+                "X",
+                "Y",
+                1,
+            ),
+            (
+                "X",
+                "Y Z",
+                3,
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_permutations_invariance(self):
+        cases = [
+            (
+                ["i", "am i good"],
+                ["i am", "i good"],
+                0.6,
+            ),
+            (
+                ["am i good", "i"],
+                [
+                    "i good",
+                    "i am",
+                ],
+                0.6,
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_return_dict(self):
+        # TODO: remove unit test once deprecated
+        with pytest.deprecated_call():
+            return_dict = jiwer.cer(
+                ["i", "am i good"], ["i am", "y good"], return_dict=True
+            )
+
+        assert_dict_almost_equal(
+            self,
+            return_dict,
+            {
+                "cer": 0.7,
+                "hits": 6,
+                "substitutions": 1,
+                "deletions": 3,
+                "insertions": 3,
+            },
+            delta=1e-16,
+        )
+
+    def _apply_test_on(self, cases):
+        for ref, hyp, correct_cer in cases:
+            cer = jiwer.cer(reference=ref, hypothesis=hyp)
+
+            self.assertTrue(isinstance(cer, float))
+            if isinstance(cer, float):
+                self.assertAlmostEqual(cer, correct_cer, delta=1e-16)

jiwer/tests/test_measures.py

@@ -0,0 +1,410 @@
+import unittest
+
+import pytest
+
+import jiwer
+
+
+def all_m(wer, mer, wil):
+    return {
+        "wer": wer,
+        "mer": mer,
+        "wip": 1 - wil,
+        "wil": wil,
+    }
+
+
+def to_measure_dict(x: jiwer.WordOutput):
+    return {"wer": x.wer, "mer": x.mer, "wip": x.wip, "wil": x.wil}
+
+
+def assert_dict_almost_equal(
+    test_case: unittest.TestCase, a, b, places=None, msg=None, delta=None
+):
+    test_case.assertIsInstance(a, dict)
+    test_case.assertIsInstance(b, dict)
+    test_case.assertEqual(set(a.keys()), set(b.keys()))
+
+    for k in a.keys():
+        test_case.assertAlmostEqual(a[k], b[k], places=places, msg=msg, delta=delta)
+
+
+class TestMeasuresContiguousSentencesTransform(unittest.TestCase):
+    def test_input_ref_string_hyp_string(self):
+        cases = [
+            ("This is a test", "This is a test", all_m(0, 0, 0)),
+            ("This is a test", "", all_m(1, 1, 1)),
+            ("This is a test", "This test", all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_string_hyp_list(self):
+        cases = [
+            ("This is a test", ["This is a test"], all_m(0, 0, 0)),
+            ("This is a test", [""], all_m(1, 1, 1)),
+            ("This is a test", ["This test"], all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_list_hyp_string(self):
+        cases = [
+            (["This is a test"], "This is a test", all_m(0, 0, 0)),
+            (["This is a test"], "", all_m(1, 1, 1)),
+            (["This is a test"], "This test", all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_ref_list_hyp_list(self):
+        cases = [
+            (["This is a test"], ["This is a test"], all_m(0, 0, 0)),
+            (["This is a test"], [""], all_m(1, 1, 1)),
+            (["This is a test"], ["This test"], all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_different_sentence_length_equal_type(self):
+        cases = [
+            (
+                ["hello", "this", "sentence", "is fractured"],
+                ["this sentence"],
+                all_m(0.6, 0.6, 0.6),
+            ),
+            (
+                "i am a short ground truth",
+                "i am a considerably longer and very much incorrect hypothesis",
+                all_m(7 / 6, 0.7, 0.85),
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_different_sentence_length_unequaL_type(self):
+        reference = [
+            "i like monthy python",
+            "what do you mean african or european swallow",
+        ]
+        hypothesis = ["i like", "python", "what you mean", "or swallow"]
+        x = jiwer.process_words(
+            reference,
+            hypothesis,
+            reference_transform=jiwer.transformations.wer_contiguous,
+            hypothesis_transform=jiwer.transformations.wer_contiguous,
+        )
+        x_dict = to_measure_dict(x)
+
+        # is equivalent to
+
+        reference = "i like monthy python what do you mean african or european swallow"
+        hypothesis = "i like python what you mean or swallow"
+        y = jiwer.process_words(
+            reference,
+            hypothesis,
+            reference_transform=jiwer.transformations.wer_contiguous,
+            hypothesis_transform=jiwer.transformations.wer_contiguous,
+        )
+        y_dict = to_measure_dict(y)
+
+        assert_dict_almost_equal(self, x_dict, y_dict, delta=1e-9)
+
+    def test_fail_on_empty_reference(self):
+        for method in [
+            jiwer.wer,
+            jiwer.wil,
+            jiwer.wip,
+            jiwer.mer,
+            jiwer.compute_measures,
+        ]:
+
+            def callback():
+                method("", "test")
+
+            self.assertRaises(ValueError, callback)
+
+    def test_known_values(self):
+        # Taken from the "From WER and RIL to MER and WIL" paper, for link see README.md
+        cases = [
+            (
+                "X",
+                "X",
+                all_m(0, 0, 0),
+            ),
+            (
+                "X",
+                "X X Y Y",
+                all_m(3, 0.75, 0.75),
+            ),
+            (
+                "X Y X",
+                "X Z",
+                all_m(2 / 3, 2 / 3, 5 / 6),
+            ),
+            (
+                "X",
+                "Y",
+                all_m(1, 1, 1),
+            ),
+            (
+                "X",
+                "Y Z",
+                all_m(2, 1, 1),
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_permutations_variance(self):
+        cases = [
+            (
+                ["i", "am i good"],
+                ["i am", "i good"],
+                all_m(0.0, 0.0, 0),
+            ),
+            (
+                ["am i good", "i"],
+                [
+                    "i good",
+                    "i am",
+                ],
+                all_m(0.5, 0.4, 7 / 16),
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def _apply_test_on(self, cases):
+        for ref, hyp, correct_measures in cases:
+            output = jiwer.process_words(
+                reference=ref,
+                hypothesis=hyp,
+                reference_transform=jiwer.transformations.wer_contiguous,
+                hypothesis_transform=jiwer.transformations.wer_contiguous,
+            )
+            output_dict = to_measure_dict(output)
+
+            assert_dict_almost_equal(self, output_dict, correct_measures, delta=1e-16)
+
+
+class TestMeasuresDefaultTransform(unittest.TestCase):
+    def test_input_gt_string_h_string(self):
+        cases = [
+            ("This is a test", "This is a test", all_m(0, 0, 0)),
+            ("This is a test", "", all_m(1, 1, 1)),
+            ("This is a test", "This test", all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_gt_string_h_list(self):
+        cases = [
+            ("This is a test", ["This is a test"], all_m(0, 0, 0)),
+            ("This is a test", [""], all_m(1, 1, 1)),
+            ("This is a test", ["This test"], all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_gt_list_h_string(self):
+        cases = [
+            (["This is a test"], "This is a test", all_m(0, 0, 0)),
+            (["This is a test"], "", all_m(1, 1, 1)),
+            (["This is a test"], "This test", all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_input_gt_list_h_list(self):
+        cases = [
+            (["This is a test"], ["This is a test"], all_m(0, 0, 0)),
+            (["This is a test"], [""], all_m(1, 1, 1)),
+            (["This is a test"], ["This test"], all_m(0.5, 0.5, 0.5)),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_fail_on_different_sentence_length(self):
+        for method in [
+            jiwer.process_words,
+            jiwer.wer,
+            jiwer.wil,
+            jiwer.wip,
+            jiwer.mer,
+            jiwer.compute_measures,
+        ]:
+
+            def callback():
+                method(["hello", "this", "sentence", "is fractured"], ["this sentence"])
+
+            self.assertRaises(ValueError, callback)
+
+    def test_fail_on_empty_reference(self):
+        for method in [
+            jiwer.process_words,
+            jiwer.wer,
+            jiwer.wil,
+            jiwer.wip,
+            jiwer.mer,
+            jiwer.compute_measures,
+        ]:
+
+            def callback():
+                method("", "test")
+
+            self.assertRaises(ValueError, callback)
+
+    def test_known_values(self):
+        # Taken from the "From WER and RIL to MER and WIL" paper, for link see README.md
+        cases = [
+            (
+                "X",
+                "X",
+                all_m(0, 0, 0),
+            ),
+            (
+                "X",
+                "X X Y Y",
+                all_m(3, 0.75, 0.75),
+            ),
+            (
+                "X Y X",
+                "X Z",
+                all_m(2 / 3, 2 / 3, 5 / 6),
+            ),
+            (
+                "X",
+                "Y",
+                all_m(1, 1, 1),
+            ),
+            (
+                "X",
+                "Y Z",
+                all_m(2, 1, 1),
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def test_permutations_invariance(self):
+        cases = [
+            (
+                ["i", "am i good"],
+                ["i am", "i good"],
+                all_m(0.5, 0.4, 7 / 16),
+            ),
+            (
+                ["am i good", "i"],
+                [
+                    "i good",
+                    "i am",
+                ],
+                all_m(0.5, 0.4, 7 / 16),
+            ),
+        ]
+
+        self._apply_test_on(cases)
+
+    def _apply_test_on(self, cases):
+        for ref, hyp, correct_measures in cases:
+            output = jiwer.process_words(reference=ref, hypothesis=hyp)
+            output_dict = to_measure_dict(output)
+
+            assert_dict_almost_equal(self, output_dict, correct_measures, delta=1e-16)
+
+            with pytest.deprecated_call():
+                output = jiwer.compute_measures(truth=ref, hypothesis=hyp)
+                output_dict = {
+                    "wer": output["wer"],
+                    "mer": output["mer"],
+                    "wil": output["wil"],
+                    "wip": output["wip"],
+                }
+                assert_dict_almost_equal(
+                    self, output_dict, correct_measures, delta=1e-16
+                )
+
+        self._apply_test_deprecated_truth(cases)
+
+    def _apply_test_deprecated_truth(self, cases):
+        with pytest.deprecated_call():
+            for ref, hyp, correct_measures in cases:
+                output_dict = {}
+                for key, method in [
+                    ("wer", jiwer.wer),
+                    ("mer", jiwer.mer),
+                    ("wil", jiwer.wil),
+                    ("wip", jiwer.wip),
+                ]:
+                    output = method(truth=ref, hypothesis=hyp)
+                    output_dict[key] = output
+
+                assert_dict_almost_equal(
+                    self, output_dict, correct_measures, delta=1e-16
+                )
+
+    def test_deprecated_truth_and_ref(self):
+        for key, method in [
+            ("wer", jiwer.wer),
+            ("mer", jiwer.mer),
+            ("wil", jiwer.wil),
+            ("wip", jiwer.wip),
+            ("cer", jiwer.cer),
+        ]:
+            with pytest.raises(ValueError):
+                method(truth="ref", reference="truth", hypothesis="huh")
+                method()
+                method(truth="only truth")
+                method(reference="only ref")
+                method(hypothesis="only hypothesis")
+
+    def test_deprecated_truth_and_ref_with_transform(self):
+        wer_transform = jiwer.Compose(
+            [
+                jiwer.ToLowerCase(),
+                jiwer.RemoveMultipleSpaces(),
+                jiwer.Strip(),
+                jiwer.ReduceToListOfListOfWords(),
+            ]
+        )
+        cer_transform = jiwer.Compose(
+            [
+                jiwer.ToLowerCase(),
+                jiwer.RemoveMultipleSpaces(),
+                jiwer.Strip(),
+                jiwer.ReduceToListOfListOfChars(),
+            ]
+        )
+
+        for key, method in [
+            ("wer", jiwer.wer),
+            ("mer", jiwer.mer),
+            ("wil", jiwer.wil),
+            ("wip", jiwer.wip),
+            ("cer", jiwer.cer),
+        ]:
+            if key == "cer":
+                tr = cer_transform
+            else:
+                tr = wer_transform
+
+            result = method(
+                truth="This is a short Sentence with a few Words with upper and Lower cases",
+                hypothesis="His is a short Sentence with a few Words with upper and Lower cases",
+                truth_transform=tr,
+                hypothesis_transform=tr,
+            )
+            result_same = method(
+                reference="This is a short Sentence with a few Words with upper and Lower cases",
+                hypothesis="His is a short Sentence with a few Words with upper and Lower cases",
+                reference_transform=tr,
+                hypothesis_transform=tr,
+            )
+            self.assertAlmostEqual(result, result_same)
+
+
+def test_deprecate_compute_measures():
+    # TODO: remove once deprecated
+    with pytest.deprecated_call():
+        jiwer.compute_measures("no more", "compute_measures")

jiwer/tests/test_speed.py

@@ -0,0 +1,24 @@
+from jiwer import wer
+
+
+def perform_computation(num_sentences):
+    truth = ["this is a speed test" for _ in range(0, num_sentences)]
+    hypo = ["this is not a speed test" for _ in range(0, num_sentences)]
+
+    wer(truth, hypo)
+
+
+def test_speed_n1(benchmark):
+    benchmark(perform_computation, 1)
+
+
+def test_speed_n10(benchmark):
+    benchmark(perform_computation, 10)
+
+
+def test_speed_n100(benchmark):
+    benchmark(perform_computation, 100)
+
+
+def test_speed_n1000(benchmark):
+    benchmark(perform_computation, 1000)

jiwer/tests/test_transforms.py

@@ -0,0 +1,337 @@
+import unittest
+
+from jiwer.transforms import *
+from jiwer.transforms import ReduceToListOfListOfChars
+
+
+def _apply_test_on(self: unittest.TestCase, tr, cases):
+    for inp, outp in cases:
+        self.assertEqual(outp, tr(inp))
+
+
+class TestReduceToSingleSentence(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            ("this is a test", "this is a test"),
+            ("", ""),
+            (["this is one", "is two"], ["this is one is two"]),
+            (["one", "two", "three", "", "five six"], ["one two three five six"]),
+            ([""], []),
+        ]
+
+        _apply_test_on(self, ReduceToSingleSentence(), cases)
+
+    def test_delimiter(self):
+        cases = [
+            ("this_is_a_test", "this_is_a_test"),
+            ("", ""),
+            (["this_is_one", "is_two"], ["this_is_one_is_two"]),
+            (["one", "two", "three", "", "five_six"], ["one_two_three_five_six"]),
+            ([""], []),
+        ]
+
+        _apply_test_on(self, ReduceToSingleSentence("_"), cases)
+
+
+class TestReduceToListOfListOfWords(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            ("this is a test", [["this", "is", "a", "test"]]),
+            ("", [[]]),
+            (["this is one", "is two"], [["this", "is", "one"], ["is", "two"]]),
+            (
+                ["one", "two", "three", "", "five six"],
+                [["one"], ["two"], ["three"], [], ["five", "six"]],
+            ),
+            ([], [[]]),
+            ([""], [[]]),
+            (["", "", ""], [[], [], []]),
+        ]
+
+        _apply_test_on(self, ReduceToListOfListOfWords(), cases)
+
+    def test_delimiter(self):
+        cases = [
+            ("this_is_a_test", [["this", "is", "a", "test"]]),
+            ("", [[]]),
+            (["this_is_one", "is_two"], [["this", "is", "one"], ["is", "two"]]),
+            (
+                ["one", "two", "three", "", "five_six"],
+                [["one"], ["two"], ["three"], [], ["five", "six"]],
+            ),
+            ([], [[]]),
+            ([""], [[]]),
+            (["", "", ""], [[], [], []]),
+        ]
+
+        _apply_test_on(self, ReduceToListOfListOfWords("_"), cases)
+
+
+class TestReduceToListOfListOfChars(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (
+                "this is a test",
+                [
+                    [
+                        "t",
+                        "h",
+                        "i",
+                        "s",
+                        " ",
+                        "i",
+                        "s",
+                        " ",
+                        "a",
+                        " ",
+                        "t",
+                        "e",
+                        "s",
+                        "t",
+                    ]
+                ],
+            ),
+            ("", [[]]),
+            (
+                ["this is one", "is two"],
+                [
+                    ["t", "h", "i", "s", " ", "i", "s", " ", "o", "n", "e"],
+                    ["i", "s", " ", "t", "w", "o"],
+                ],
+            ),
+            (
+                ["one", "two", "three", "", "five six"],
+                [
+                    ["o", "n", "e"],
+                    ["t", "w", "o"],
+                    ["t", "h", "r", "e", "e"],
+                    [],
+                    ["f", "i", "v", "e", " ", "s", "i", "x"],
+                ],
+            ),
+            ([], [[]]),
+            ([""], [[]]),
+            (["", "", ""], [[], [], []]),
+        ]
+
+        _apply_test_on(self, ReduceToListOfListOfChars(), cases)
+
+    def test_delimiter(self):
+        cases = [
+            (
+                "this_is_a_test",
+                [
+                    [
+                        "t",
+                        "h",
+                        "i",
+                        "s",
+                        "_",
+                        "i",
+                        "s",
+                        "_",
+                        "a",
+                        "_",
+                        "t",
+                        "e",
+                        "s",
+                        "t",
+                    ]
+                ],
+            ),
+            ("", [[]]),
+            (
+                ["this_is_one", "is_two"],
+                [
+                    ["t", "h", "i", "s", "_", "i", "s", "_", "o", "n", "e"],
+                    ["i", "s", "_", "t", "w", "o"],
+                ],
+            ),
+            (
+                ["one", "two", "three", "", "five_six"],
+                [
+                    ["o", "n", "e"],
+                    ["t", "w", "o"],
+                    ["t", "h", "r", "e", "e"],
+                    [],
+                    ["f", "i", "v", "e", "_", "s", "i", "x"],
+                ],
+            ),
+            ([], [[]]),
+            ([""], [[]]),
+            (["", "", ""], [[], [], []]),
+        ]
+
+        _apply_test_on(self, ReduceToListOfListOfChars(), cases)
+
+
+class TestRemoveSpecificWords(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["yhe about that bug"], ["  about that bug"]),
+            (["yeah about that bug"], ["  about that bug"]),
+            (["one bug"], ["one bug"]),
+            (["yhe", "about", "bug"], [" ", "about", "bug"]),
+            (["yeah", "about", "bug"], [" ", "about", "bug"]),
+            (["one", "bug"], ["one", "bug"]),
+            (["yhe about bug"], ["  about bug"]),
+            (["yeah about bug"], ["  about bug"]),
+            (["about bug yhe"], ["about bug  "]),
+            (["one bug"], ["one bug"]),
+            (["he asked a helpful question"], ["  asked   helpful question"]),
+            (["normal sentence"], ["normal sentence"]),
+            (["yhe awesome", "  awesome"]),
+            (["the apple is not a pear", "  apple is not   pear"]),
+            (["yhe", " "]),
+        ]
+
+        _apply_test_on(
+            self, RemoveSpecificWords(["yhe", "yeah", "a", "he", "the"]), cases
+        )
+
+
+class TestRemoveWhiteSpace(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["this is an example", "thisisanexample"]),
+            (["hello\tworld\n\r", "helloworld"]),
+        ]
+
+        _apply_test_on(self, RemoveWhiteSpace(), cases)
+
+    def test_replace_by_space(self):
+        cases = [
+            (["this is an example", "this is an example"]),
+            (["hello\tworld\n\r", "hello world  "]),
+        ]
+
+        _apply_test_on(self, RemoveWhiteSpace(replace_by_space=True), cases)
+
+
+class TestRemovePunctuation(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["this is an example!", "this is an example"]),
+            (["hello. goodbye", "hello goodbye"]),
+            (["this sentence has no punctuation", "this sentence has no punctuation"]),
+        ]
+
+        _apply_test_on(self, RemovePunctuation(), cases)
+
+    def test_non_ascii_punctuation(self):
+        cases = [
+            (["word༆’'", "word"]),
+            (["‘no’", "no"]),
+            (["“yes”", "yes"]),
+        ]
+
+        _apply_test_on(self, RemovePunctuation(), cases)
+
+
+class TestRemoveMultipleSpaces(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["this is   an   example "], ["this is an example "]),
+            (["  hello goodbye  "], [" hello goodbye "]),
+            (["  "], [" "]),
+        ]
+
+        _apply_test_on(self, RemoveMultipleSpaces(), cases)
+
+    pass
+
+
+class TestSubstituteWords(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["you're pretty"], ["i am awesome"]),
+            (["your book"], ["your book"]),
+            (["foobar"], ["foobar"]),
+        ]
+
+        _apply_test_on(
+            self,
+            SubstituteWords(
+                {"pretty": "awesome", "you": "i", "'re": " am", "foo": "bar"}
+            ),
+            cases,
+        )
+
+
+class TestSubstituteRegexes(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["is the world doomed or loved?"], ["is the world sacr or lov?"]),
+            (["the sun is loved"], ["the sun is lov"]),
+            (["edibles are allegedly cultivated"], ["edibles are allegedly cultivat"]),
+        ]
+
+        _apply_test_on(
+            self,
+            SubstituteRegexes({r"doom": r"sacr", r"\b(\w+)ed\b": r"\1"}),
+            cases,
+        )
+
+
+class TestStrip(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            ([" this is an example "], ["this is an example"]),
+            (["  hello goodbye  "], ["hello goodbye"]),
+            (["  "], [""]),
+            (["                       "], [""]),
+        ]
+
+        _apply_test_on(self, Strip(), cases)
+
+
+class TestRemoveEmptyStrings(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            ([""], []),
+            (["this is an example"], ["this is an example"]),
+            ([" "], []),
+            (["                "], []),
+        ]
+
+        _apply_test_on(self, RemoveEmptyStrings(), cases)
+
+
+class TestExpandCommonEnglishContractions(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (
+                ["she'll make sure you can't make it"],
+                ["she will make sure you can not make it"],
+            ),
+            (["let's party!"], ["let us party!"]),
+        ]
+
+        _apply_test_on(self, ExpandCommonEnglishContractions(), cases)
+
+
+class TestToLowerCase(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["You're PRETTY"], ["you're pretty"]),
+        ]
+
+        _apply_test_on(self, ToLowerCase(), cases)
+
+
+class TestToUpperCase(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["You're amazing"], ["YOU'RE AMAZING"]),
+        ]
+
+        _apply_test_on(self, ToUpperCase(), cases)
+
+
+class TestRemoveKaldiNonWords(unittest.TestCase):
+    def test_normal(self):
+        cases = [
+            (["you <unk> like [laugh]"], ["you  like "]),
+        ]
+
+        _apply_test_on(self, RemoveKaldiNonWords(), cases)