whispercpp 1.3.6 → 1.3.7

data/ext/sources/tests/earnings21/normalizers/english.py

@@ -1,550 +0,0 @@
-import json
-import os
-import re
-from fractions import Fraction
-from typing import Iterator, List, Match, Optional, Union
-
-from more_itertools import windowed
-
-from .basic import remove_symbols_and_diacritics
-
-
-class EnglishNumberNormalizer:
-    """
-    Convert any spelled-out numbers into arabic numbers, while handling:
-
-    - remove any commas
-    - keep the suffixes such as: `1960s`, `274th`, `32nd`, etc.
-    - spell out currency symbols after the number. e.g. `$20 million` -> `20000000 dollars`
-    - spell out `one` and `ones`
-    - interpret successive single-digit numbers as nominal: `one oh one` -> `101`
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.zeros = {"o", "oh", "zero"}
-        self.ones = {
-            name: i
-            for i, name in enumerate(
-                [
-                    "one",
-                    "two",
-                    "three",
-                    "four",
-                    "five",
-                    "six",
-                    "seven",
-                    "eight",
-                    "nine",
-                    "ten",
-                    "eleven",
-                    "twelve",
-                    "thirteen",
-                    "fourteen",
-                    "fifteen",
-                    "sixteen",
-                    "seventeen",
-                    "eighteen",
-                    "nineteen",
-                ],
-                start=1,
-            )
-        }
-        self.ones_plural = {
-            "sixes" if name == "six" else name + "s": (value, "s")
-            for name, value in self.ones.items()
-        }
-        self.ones_ordinal = {
-            "zeroth": (0, "th"),
-            "first": (1, "st"),
-            "second": (2, "nd"),
-            "third": (3, "rd"),
-            "fifth": (5, "th"),
-            "twelfth": (12, "th"),
-            **{
-                name + ("h" if name.endswith("t") else "th"): (value, "th")
-                for name, value in self.ones.items()
-                if value > 3 and value != 5 and value != 12
-            },
-        }
-        self.ones_suffixed = {**self.ones_plural, **self.ones_ordinal}
-
-        self.tens = {
-            "twenty": 20,
-            "thirty": 30,
-            "forty": 40,
-            "fifty": 50,
-            "sixty": 60,
-            "seventy": 70,
-            "eighty": 80,
-            "ninety": 90,
-        }
-        self.tens_plural = {
-            name.replace("y", "ies"): (value, "s") for name, value in self.tens.items()
-        }
-        self.tens_ordinal = {
-            name.replace("y", "ieth"): (value, "th")
-            for name, value in self.tens.items()
-        }
-        self.tens_suffixed = {**self.tens_plural, **self.tens_ordinal}
-
-        self.multipliers = {
-            "hundred": 100,
-            "thousand": 1_000,
-            "million": 1_000_000,
-            "billion": 1_000_000_000,
-            "trillion": 1_000_000_000_000,
-            "quadrillion": 1_000_000_000_000_000,
-            "quintillion": 1_000_000_000_000_000_000,
-            "sextillion": 1_000_000_000_000_000_000_000,
-            "septillion": 1_000_000_000_000_000_000_000_000,
-            "octillion": 1_000_000_000_000_000_000_000_000_000,
-            "nonillion": 1_000_000_000_000_000_000_000_000_000_000,
-            "decillion": 1_000_000_000_000_000_000_000_000_000_000_000,
-        }
-        self.multipliers_plural = {
-            name + "s": (value, "s") for name, value in self.multipliers.items()
-        }
-        self.multipliers_ordinal = {
-            name + "th": (value, "th") for name, value in self.multipliers.items()
-        }
-        self.multipliers_suffixed = {
-            **self.multipliers_plural,
-            **self.multipliers_ordinal,
-        }
-        self.decimals = {*self.ones, *self.tens, *self.zeros}
-
-        self.preceding_prefixers = {
-            "minus": "-",
-            "negative": "-",
-            "plus": "+",
-            "positive": "+",
-        }
-        self.following_prefixers = {
-            "pound": "£",
-            "pounds": "£",
-            "euro": "€",
-            "euros": "€",
-            "dollar": "$",
-            "dollars": "$",
-            "cent": "¢",
-            "cents": "¢",
-        }
-        self.prefixes = set(
-            list(self.preceding_prefixers.values())
-            + list(self.following_prefixers.values())
-        )
-        self.suffixers = {
-            "per": {"cent": "%"},
-            "percent": "%",
-        }
-        self.specials = {"and", "double", "triple", "point"}
-
-        self.words = set(
-            [
-                key
-                for mapping in [
-                    self.zeros,
-                    self.ones,
-                    self.ones_suffixed,
-                    self.tens,
-                    self.tens_suffixed,
-                    self.multipliers,
-                    self.multipliers_suffixed,
-                    self.preceding_prefixers,
-                    self.following_prefixers,
-                    self.suffixers,
-                    self.specials,
-                ]
-                for key in mapping
-            ]
-        )
-        self.literal_words = {"one", "ones"}
-
-    def process_words(self, words: List[str]) -> Iterator[str]:
-        prefix: Optional[str] = None
-        value: Optional[Union[str, int]] = None
-        skip = False
-
-        def to_fraction(s: str):
-            try:
-                return Fraction(s)
-            except ValueError:
-                return None
-
-        def output(result: Union[str, int]):
-            nonlocal prefix, value
-            result = str(result)
-            if prefix is not None:
-                result = prefix + result
-            value = None
-            prefix = None
-            return result
-
-        if len(words) == 0:
-            return
-
-        for prev, current, next in windowed([None] + words + [None], 3):
-            if skip:
-                skip = False
-                continue
-
-            next_is_numeric = next is not None and re.match(r"^\d+(\.\d+)?$", next)
-            has_prefix = current[0] in self.prefixes
-            current_without_prefix = current[1:] if has_prefix else current
-            if re.match(r"^\d+(\.\d+)?$", current_without_prefix):
-                # arabic numbers (potentially with signs and fractions)
-                f = to_fraction(current_without_prefix)
-                assert f is not None
-                if value is not None:
-                    if isinstance(value, str) and value.endswith("."):
-                        # concatenate decimals / ip address components
-                        value = str(value) + str(current)
-                        continue
-                    else:
-                        yield output(value)
-
-                prefix = current[0] if has_prefix else prefix
-                if f.denominator == 1:
-                    value = f.numerator  # store integers as int
-                else:
-                    value = current_without_prefix
-            elif current not in self.words:
-                # non-numeric words
-                if value is not None:
-                    yield output(value)
-                yield output(current)
-            elif current in self.zeros:
-                value = str(value or "") + "0"
-            elif current in self.ones:
-                ones = self.ones[current]
-
-                if value is None:
-                    value = ones
-                elif isinstance(value, str) or prev in self.ones:
-                    if (
-                        prev in self.tens and ones < 10
-                    ):  # replace the last zero with the digit
-                        assert value[-1] == "0"
-                        value = value[:-1] + str(ones)
-                    else:
-                        value = str(value) + str(ones)
-                elif ones < 10:
-                    if value % 10 == 0:
-                        value += ones
-                    else:
-                        value = str(value) + str(ones)
-                else:  # eleven to nineteen
-                    if value % 100 == 0:
-                        value += ones
-                    else:
-                        value = str(value) + str(ones)
-            elif current in self.ones_suffixed:
-                # ordinal or cardinal; yield the number right away
-                ones, suffix = self.ones_suffixed[current]
-                if value is None:
-                    yield output(str(ones) + suffix)
-                elif isinstance(value, str) or prev in self.ones:
-                    if prev in self.tens and ones < 10:
-                        assert value[-1] == "0"
-                        yield output(value[:-1] + str(ones) + suffix)
-                    else:
-                        yield output(str(value) + str(ones) + suffix)
-                elif ones < 10:
-                    if value % 10 == 0:
-                        yield output(str(value + ones) + suffix)
-                    else:
-                        yield output(str(value) + str(ones) + suffix)
-                else:  # eleven to nineteen
-                    if value % 100 == 0:
-                        yield output(str(value + ones) + suffix)
-                    else:
-                        yield output(str(value) + str(ones) + suffix)
-                value = None
-            elif current in self.tens:
-                tens = self.tens[current]
-                if value is None:
-                    value = tens
-                elif isinstance(value, str):
-                    value = str(value) + str(tens)
-                else:
-                    if value % 100 == 0:
-                        value += tens
-                    else:
-                        value = str(value) + str(tens)
-            elif current in self.tens_suffixed:
-                # ordinal or cardinal; yield the number right away
-                tens, suffix = self.tens_suffixed[current]
-                if value is None:
-                    yield output(str(tens) + suffix)
-                elif isinstance(value, str):
-                    yield output(str(value) + str(tens) + suffix)
-                else:
-                    if value % 100 == 0:
-                        yield output(str(value + tens) + suffix)
-                    else:
-                        yield output(str(value) + str(tens) + suffix)
-            elif current in self.multipliers:
-                multiplier = self.multipliers[current]
-                if value is None:
-                    value = multiplier
-                elif isinstance(value, str) or value == 0:
-                    f = to_fraction(value)
-                    p = f * multiplier if f is not None else None
-                    if f is not None and p.denominator == 1:
-                        value = p.numerator
-                    else:
-                        yield output(value)
-                        value = multiplier
-                else:
-                    before = value // 1000 * 1000
-                    residual = value % 1000
-                    value = before + residual * multiplier
-            elif current in self.multipliers_suffixed:
-                multiplier, suffix = self.multipliers_suffixed[current]
-                if value is None:
-                    yield output(str(multiplier) + suffix)
-                elif isinstance(value, str):
-                    f = to_fraction(value)
-                    p = f * multiplier if f is not None else None
-                    if f is not None and p.denominator == 1:
-                        yield output(str(p.numerator) + suffix)
-                    else:
-                        yield output(value)
-                        yield output(str(multiplier) + suffix)
-                else:  # int
-                    before = value // 1000 * 1000
-                    residual = value % 1000
-                    value = before + residual * multiplier
-                    yield output(str(value) + suffix)
-                value = None
-            elif current in self.preceding_prefixers:
-                # apply prefix (positive, minus, etc.) if it precedes a number
-                if value is not None:
-                    yield output(value)
-
-                if next in self.words or next_is_numeric:
-                    prefix = self.preceding_prefixers[current]
-                else:
-                    yield output(current)
-            elif current in self.following_prefixers:
-                # apply prefix (dollars, cents, etc.) only after a number
-                if value is not None:
-                    prefix = self.following_prefixers[current]
-                    yield output(value)
-                else:
-                    yield output(current)
-            elif current in self.suffixers:
-                # apply suffix symbols (percent -> '%')
-                if value is not None:
-                    suffix = self.suffixers[current]
-                    if isinstance(suffix, dict):
-                        if next in suffix:
-                            yield output(str(value) + suffix[next])
-                            skip = True
-                        else:
-                            yield output(value)
-                            yield output(current)
-                    else:
-                        yield output(str(value) + suffix)
-                else:
-                    yield output(current)
-            elif current in self.specials:
-                if next not in self.words and not next_is_numeric:
-                    # apply special handling only if the next word can be numeric
-                    if value is not None:
-                        yield output(value)
-                    yield output(current)
-                elif current == "and":
-                    # ignore "and" after hundreds, thousands, etc.
-                    if prev not in self.multipliers:
-                        if value is not None:
-                            yield output(value)
-                        yield output(current)
-                elif current == "double" or current == "triple":
-                    if next in self.ones or next in self.zeros:
-                        repeats = 2 if current == "double" else 3
-                        ones = self.ones.get(next, 0)
-                        value = str(value or "") + str(ones) * repeats
-                        skip = True
-                    else:
-                        if value is not None:
-                            yield output(value)
-                        yield output(current)
-                elif current == "point":
-                    if next in self.decimals or next_is_numeric:
-                        value = str(value or "") + "."
-                else:
-                    # should all have been covered at this point
-                    raise ValueError(f"Unexpected token: {current}")
-            else:
-                # all should have been covered at this point
-                raise ValueError(f"Unexpected token: {current}")
-
-        if value is not None:
-            yield output(value)
-
-    def preprocess(self, s: str):
-        # replace "<number> and a half" with "<number> point five"
-        results = []
-
-        segments = re.split(r"\band\s+a\s+half\b", s)
-        for i, segment in enumerate(segments):
-            if len(segment.strip()) == 0:
-                continue
-            if i == len(segments) - 1:
-                results.append(segment)
-            else:
-                results.append(segment)
-                last_word = segment.rsplit(maxsplit=2)[-1]
-                if last_word in self.decimals or last_word in self.multipliers:
-                    results.append("point five")
-                else:
-                    results.append("and a half")
-
-        s = " ".join(results)
-
-        # put a space at number/letter boundary
-        s = re.sub(r"([a-z])([0-9])", r"\1 \2", s)
-        s = re.sub(r"([0-9])([a-z])", r"\1 \2", s)
-
-        # but remove spaces which could be a suffix
-        s = re.sub(r"([0-9])\s+(st|nd|rd|th|s)\b", r"\1\2", s)
-
-        return s
-
-    def postprocess(self, s: str):
-        def combine_cents(m: Match):
-            try:
-                currency = m.group(1)
-                integer = m.group(2)
-                cents = int(m.group(3))
-                return f"{currency}{integer}.{cents:02d}"
-            except ValueError:
-                return m.string
-
-        def extract_cents(m: Match):
-            try:
-                return f"¢{int(m.group(1))}"
-            except ValueError:
-                return m.string
-
-        # apply currency postprocessing; "$2 and ¢7" -> "$2.07"
-        s = re.sub(r"([€£$])([0-9]+) (?:and )?¢([0-9]{1,2})\b", combine_cents, s)
-        s = re.sub(r"[€£$]0.([0-9]{1,2})\b", extract_cents, s)
-
-        # write "one(s)" instead of "1(s)", just for the readability
-        s = re.sub(r"\b1(s?)\b", r"one\1", s)
-
-        return s
-
-    def __call__(self, s: str):
-        s = self.preprocess(s)
-        s = " ".join(word for word in self.process_words(s.split()) if word is not None)
-        s = self.postprocess(s)
-
-        return s
-
-
-class EnglishSpellingNormalizer:
-    """
-    Applies British-American spelling mappings as listed in [1].
-
-    [1] https://www.tysto.com/uk-us-spelling-list.html
-    """
-
-    def __init__(self):
-        mapping_path = os.path.join(os.path.dirname(__file__), "english.json")
-        self.mapping = json.load(open(mapping_path))
-
-    def __call__(self, s: str):
-        return " ".join(self.mapping.get(word, word) for word in s.split())
-
-
-class EnglishTextNormalizer:
-    def __init__(self):
-        self.ignore_patterns = r"\b(hmm|mm|mhm|mmm|uh|um)\b"
-        self.replacers = {
-            # common contractions
-            r"\bwon't\b": "will not",
-            r"\bcan't\b": "can not",
-            r"\blet's\b": "let us",
-            r"\bain't\b": "aint",
-            r"\by'all\b": "you all",
-            r"\bwanna\b": "want to",
-            r"\bgotta\b": "got to",
-            r"\bgonna\b": "going to",
-            r"\bi'ma\b": "i am going to",
-            r"\bimma\b": "i am going to",
-            r"\bwoulda\b": "would have",
-            r"\bcoulda\b": "could have",
-            r"\bshoulda\b": "should have",
-            r"\bma'am\b": "madam",
-            # contractions in titles/prefixes
-            r"\bmr\b": "mister ",
-            r"\bmrs\b": "missus ",
-            r"\bst\b": "saint ",
-            r"\bdr\b": "doctor ",
-            r"\bprof\b": "professor ",
-            r"\bcapt\b": "captain ",
-            r"\bgov\b": "governor ",
-            r"\bald\b": "alderman ",
-            r"\bgen\b": "general ",
-            r"\bsen\b": "senator ",
-            r"\brep\b": "representative ",
-            r"\bpres\b": "president ",
-            r"\brev\b": "reverend ",
-            r"\bhon\b": "honorable ",
-            r"\basst\b": "assistant ",
-            r"\bassoc\b": "associate ",
-            r"\blt\b": "lieutenant ",
-            r"\bcol\b": "colonel ",
-            r"\bjr\b": "junior ",
-            r"\bsr\b": "senior ",
-            r"\besq\b": "esquire ",
-            # prefect tenses, ideally it should be any past participles, but it's harder..
-            r"'d been\b": " had been",
-            r"'s been\b": " has been",
-            r"'d gone\b": " had gone",
-            r"'s gone\b": " has gone",
-            r"'d done\b": " had done",  # "'s done" is ambiguous
-            r"'s got\b": " has got",
-            # general contractions
-            r"n't\b": " not",
-            r"'re\b": " are",
-            r"'s\b": " is",
-            r"'d\b": " would",
-            r"'ll\b": " will",
-            r"'t\b": " not",
-            r"'ve\b": " have",
-            r"'m\b": " am",
-        }
-        self.standardize_numbers = EnglishNumberNormalizer()
-        self.standardize_spellings = EnglishSpellingNormalizer()
-
-    def __call__(self, s: str):
-        s = s.lower()
-
-        s = re.sub(r"[<\[][^>\]]*[>\]]", "", s)  # remove words between brackets
-        s = re.sub(r"\(([^)]+?)\)", "", s)  # remove words between parenthesis
-        s = re.sub(self.ignore_patterns, "", s)
-        s = re.sub(r"\s+'", "'", s)  # when there's a space before an apostrophe
-
-        for pattern, replacement in self.replacers.items():
-            s = re.sub(pattern, replacement, s)
-
-        s = re.sub(r"(\d),(\d)", r"\1\2", s)  # remove commas between digits
-        s = re.sub(r"\.([^0-9]|$)", r" \1", s)  # remove periods not followed by numbers
-        s = remove_symbols_and_diacritics(s, keep=".%$¢€£")  # keep numeric symbols
-
-        s = self.standardize_numbers(s)
-        s = self.standardize_spellings(s)
-
-        # now remove prefix/suffix symbols that are not preceded/followed by numbers
-        s = re.sub(r"[.$¢€£]([^0-9])", r" \1", s)
-        s = re.sub(r"([^0-9])%", r"\1 ", s)
-
-        s = re.sub(r"\s+", " ", s)  # replace any successive whitespaces with a space
-
-        return s

data/ext/sources/tests/earnings21/requirements.txt

@@ -1,6 +0,0 @@
-# This is the minimal set of dependencies we need to compute
-# WER score. Read Section 3.2. of the original paper
-# (https://arxiv.org/abs/2212.04356) for more contexts.
-jiwer
-regex
-more-itertools

data/ext/sources/tests/en-0-ref.txt

@@ -1 +0,0 @@
- My fellow Americans, this day has brought terrible news and great sadness to our country. At 9 o'clock this morning, Mission Control in Houston lost contact with our space shuttle, Columbia. A short time later, debris was seen falling from the skies above Texas. The Colombians lost. There are no survivors. On board was a crew of seven. Colonel Rick Husband, Lieutenant Colonel Michael Anderson, Commander Laurel Clark, Captain David Brown, Commander William McCool, Dr. Kultna Shavla, and Ilan Ramon, a colonel in the Israeli Air Force. These men and women assumed great risk in the service to all humanity. In an age when spaceflight has come to seem almost routine, it is easy to overlook the dangers of travel by rocket and the difficulties of navigating the fierce outer atmosphere of the Earth. These astronauts knew the dangers, and they faced them willingly, knowing they had a high and noble purpose in life. Because of their courage and daring and idealism, we will miss them all the more. All Americans today are thinking as well of the families of these men and women who have been given this sudden shock and grief. You're not alone. Our entire nation grieves with you. And those you love will always have the respect and gratitude of this country. The cause in which they died will continue. Mankind is led into the darkness beyond our world by the inspiration of discovery and the longing to understand. Our journey into space will go on. In the skies today, we saw destruction and tragedy. Yet farther than we can see, there is comfort and hope. In the words of the prophet Isaiah, "Lift your eyes and look to the heavens. Who created all these? He who brings out the starry hosts one by one and calls them each by name." Because of His great power and mighty strength, not one of them is missing. The same Creator who names the stars also knows the names of the seven souls we mourn today. The crew of the shuttle Columbia did not return safely to Earth, yet we can pray that all are safely home. May God bless the grieving families. And may God continue to bless America. [Silence]

data/ext/sources/tests/en-1-ref.txt

@@ -1 +0,0 @@
- Henry F. Phillips from Wikipedia, the free encyclopedia at en.wikipedia.org. Henry F. Phillips from Wikipedia, the free encyclopedia. Henry F. Phillips 1890-1958, a U.S. businessman from Portland, Oregon, has the honor of having the Phillips head screw and screwdriver named after him. The importance of the cross head screw design lies in its self-centering property, useful on automated production lines that use powered screwdrivers. Phillips' major contribution was in driving the cross head concept forward to the point where it was adopted by screw makers and automobile companies. Although he received patents for the design in 1936, U.S. Patent #2,046,343, U.S. Patents #2,046,837 to #2,046,840, it was so widely copied that by 1949 Phillips lost his patent. The American Screw Company was responsible for devising a means of manufacturing the screw, and successfully patented and licensed their method. Other screw makers of the 1930s dismissed the Phillips concept since it calls for a relatively complex recessed socket shape in the head of the screw, as distinct from the simple milled slot of a slotted type screw. The Phillips Screw Company and the American Screw Company went on to devise the Pawsadrive screw, which differs from the Phillips in that it is designed to accommodate greater torque than the Phillips. An image accompanied this article, captioned "Phillips Screw Head." The following is an info box which accompanies this article. Info box, part of the series on screw drive types. Slotted, commonly erroneously flat head. Phillips, cross head. Pawsadrive, super drive. Torques. Hex, Allen. Robertson. Tri-wing. Torx set. Spanner head. Triple square, XZN. Others, poly drive, spline drive, double hex. Many images accompanied this info box. This page was last modified on the 9th of April, 2008, at 1704. All text is available under the terms of the GNU Free Documentation License. See copyrights for details. Wikipedia is a registered trademark of the Wikimedia Foundation Incorporated, a U.S. registered 501(c)(3) tax-deductible nonprofit charity. This sound file and all text in the article are licensed under the GNU Free Documentation License, available at www.gnu.org/copyleft/fdl.html.

data/ext/sources/tests/en-2-ref.txt

@@ -1 +0,0 @@
- This is the Micro Machine Man presenting the most midget miniature motorcade of Micro Machines. Each one has dramatic details, terrific trim, precision paint jobs, plus incredible Micro Machine Pocket Playsets. There's a police station, fire station, restaurant, service station, and more. Perfect pocket portables to take anyplace. And there are many miniature playsets to play with, and each one comes with its own special edition Micro Machine vehicle and fun, fantastic features that miraculously move. Raise the boat lift at the airport marina, man the gun turret at the army base, clean your car at the car wash, raise the toll bridge. And these playsets fit together to form a Micro Machine world. Micro Machine Pocket Playsets, so tremendously tiny, so perfectly precise, so dazzlingly detailed, you'll want to pocket them all. Micro Machines are Micro Machine Pocket Playsets sold separately from Galoob. The smaller they are, the better they are.

data/ext/sources/tests/es-0-ref.txt

@@ -1 +0,0 @@
- Hola, como están todos? Mi nombre es Julián Virrueta Mendoza y en este podcast les vengo a hablar sobre la contaminación del agua. Bueno, empezaré por decir que el ser humano no está midiendo las consecuencias de sus actos. No hay duda que uno de los mayores problemas a los que se enfrentan muchas poblaciones actualmente es la contaminación del agua. Principalmente porque como bien sabemos el agua prácticamente es fundamental para la vida, por lo que la contaminación puede ser algo muy negativo para el desarrollo tanto económico como social de los pueblos o de las poblaciones próximas en ese lugar contaminado. Los comienzos de la contaminación, como lo definen muchos expertos en la materia, la contaminación del agua es causada por las actividades humanas. Es un fenómeno ambiental de importancia, el cual se comienza a producir desde los primeros intentos de industrialización para transformarse luego en un problema tan habitual como generalizado. Generalmente la contaminación del agua se produce a través de la introducción directa o indirecta en los acuíferos o caos de agua, ríos, mares, lagos, océanos, etc. o de diversas sustancias que pueden ser consideradas como contaminantes. Pero existen dos formas principales de contaminación del agua. Una de ellas tiene que ver con la contaminación natural del agua que se corresponde con el ciclo natural de esta durante el que puede entrar en contacto con ciertos constituyentes contaminantes como sustancias minerales y orgánicas disueltas o en suspensión que se vierten en la corteza terrestre, la atmósfera y en las aguas. Pero todo esto se puede contradecir si el ser humano comía sus consecuencias, si no tirara basura a los lagos, a los ríos, no tirara botes de aceite, no contaminara. Bueno amigos, yo los invito a que no contaminen el agua y que sepan cuidar la naturaleza. Los saluda su buen amigo y compañero Julián Virreta. Nos vemos. ¡Claro!

data/ext/sources/tests/librispeech/eval.mk

@@ -1,39 +0,0 @@
-PYTHON = python
-
-WHISPER_PREFIX = ../../
-WHISPER_MODEL = tiny
-
-WHISPER_CLI = $(WHISPER_PREFIX)build/bin/whisper-cli
-WHISPER_FLAGS = --no-prints --language en --output-txt
-
-# You can create eval.conf to override the WHISPER_* variables
-# defined above.
--include eval.conf
-
-# This follows the file structure of the LibriSpeech project.
-AUDIO_SRCS = $(sort $(wildcard LibriSpeech/*/*/*/*.flac))
-TRANS_TXTS = $(addsuffix .txt, $(AUDIO_SRCS))
-
-# We output the evaluation result to this file.
-DONE = $(WHISPER_MODEL).txt
-
-all: $(DONE)
-
-$(DONE): $(TRANS_TXTS)
-	$(PYTHON) eval.py > $@.tmp
-	mv $@.tmp $@
-
-# Note: This task writes to a temporary file first to
-# create the target file atomically.
-%.flac.txt: %.flac
-	$(WHISPER_CLI) $(WHISPER_FLAGS) --model $(WHISPER_PREFIX)models/ggml-$(WHISPER_MODEL).bin --file $^ --output-file $^.tmp
-	mv $^.tmp.txt $^.txt
-
-archive:
-	tar -czf $(WHISPER_MODEL).tar.gz --exclude="*.flac" LibriSpeech $(DONE)
-
-clean:
-	@rm -f $(TRANS_TXTS)
-	@rm -f $(DONE)
-
-.PHONY: all clean

data/ext/sources/tests/librispeech/eval.py

@@ -1,47 +0,0 @@
-import os
-import glob
-import jiwer
-from normalizers import EnglishTextNormalizer
-
-def get_reference():
-    ref = {}
-    for path in glob.glob('LibriSpeech/*/*/*/*.trans.txt'):
-        with open(path) as fp:
-            for line in fp:
-                code, text = line.strip().split(" ", maxsplit=1)
-                ref [code] = text
-    return ref
-
-def get_hypothesis():
-    hyp = {}
-    for path in glob.glob('LibriSpeech/*/*/*/*.flac.txt'):
-        with open(path) as fp:
-            text = fp.read().strip()
-        code = os.path.basename(path).replace('.flac.txt', '')
-        hyp[code] = text
-    return hyp
-
-def get_codes():
-    codes = []
-    for path in glob.glob('LibriSpeech/*/*/*/*.flac'):
-        codes.append(os.path.basename(path).replace('.flac', ''))
-    return sorted(codes)
-
-def main():
-    normalizer = EnglishTextNormalizer()
-
-    ref_orig = get_reference()
-    hyp_orig = get_hypothesis()
-
-    ref_clean = []
-    hyp_clean = []
-
-    for code in get_codes():
-        ref_clean.append(normalizer(ref_orig[code]))
-        hyp_clean.append(normalizer(hyp_orig[code]))
-
-    wer = jiwer.wer(ref_clean, hyp_clean)
-    print(f"WER: {wer * 100:.2f}%")
-
-if __name__ == '__main__':
-    main()

data/ext/sources/tests/librispeech/normalizers/__init__.py

@@ -1,2 +0,0 @@
-from .basic import BasicTextNormalizer as BasicTextNormalizer
-from .english import EnglishTextNormalizer as EnglishTextNormalizer