python_code
stringlengths 0
679k
| repo_name
stringlengths 9
41
| file_path
stringlengths 6
149
|
|---|---|---|
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst
from pynini.lib import pynutil
class MeasureFst(GraphFst):
"""
Finite state transducer for classifying measure, e.g.
"два килограма" -> measure { cardinal { integer: "2 кг" } }
Args:
tn_measure: Text normalization Cardinal graph
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, tn_measure, deterministic: bool = True):
super().__init__(name="measure", kind="classify", deterministic=deterministic)
tn_measure = tn_measure.tagger_graph_default @ tn_measure.verbalizer_graph
graph = tn_measure.invert().optimize()
graph = pynutil.insert("cardinal { integer: \"") + graph + pynutil.insert("\" }")
graph = self.add_tokens(graph)
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/measure.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst
from pynini.lib import pynutil
class TelephoneFst(GraphFst):
"""
Finite state transducer for classifying telephone, e.g.
"восемь девятьсот тринадцать девятьсот восемьдесят три пятьдесят шесть ноль один" -> telephone { number_part: "8-913-983-56-01" }
Args:
tn_telephone: Text normalization telephone graph
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, tn_telephone: GraphFst, deterministic: bool = True):
super().__init__(name="telephone", kind="classify", deterministic=deterministic)
tn_telephone = tn_telephone.final_graph
graph = tn_telephone.invert().optimize()
graph = pynutil.insert("number_part: \"") + graph + pynutil.insert("\"")
graph = self.add_tokens(graph)
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/telephone.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_DIGIT, GraphFst
from pynini.lib import pynutil
class OrdinalFst(GraphFst):
"""
Finite state transducer for classifying ordinals, e.g.
"второе" -> ordinal { integer: "2" } }
Args:
tn_ordinal: Text normalization Ordinal graph
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, tn_ordinal: GraphFst, deterministic: bool = True):
super().__init__(name="ordinal", kind="classify", deterministic=deterministic)
tn_ordinal = tn_ordinal.ordinal_numbers
graph = tn_ordinal.invert().optimize()
self.graph = graph
# do not invert numbers less than 10
graph = pynini.compose(graph, NEMO_DIGIT ** (2, ...))
graph = pynutil.insert("integer: \"") + graph + pynutil.insert("\"")
graph = self.add_tokens(graph)
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/ordinal.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst, convert_space
from nemo_text_processing.text_normalization.ru.utils import get_abs_path
from pynini.lib import pynutil
class WhiteListFst(GraphFst):
"""
Finite state transducer for classifying whitelist, e.g.
"квартира" -> telephone { number_part: "кв." }
Args:
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
input_file: path to a file with whitelist replacements (each line of the file: written_form\tspoken_form\n),
e.g. nemo_text_processing/inverse_text_normalization/en/data/whitelist.tsv
"""
def __init__(self, deterministic: bool = True, input_file: str = None):
super().__init__(name="whitelist", kind="classify", deterministic=deterministic)
if input_file:
whitelist = pynini.string_file(input_file).invert()
else:
whitelist = pynini.string_file(get_abs_path("data/whitelist.tsv")).invert()
graph = pynutil.insert("name: \"") + convert_space(whitelist) + pynutil.insert("\"")
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/whitelist.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import logging
import os
import pynini
from nemo_text_processing.inverse_text_normalization.en.taggers.punctuation import PunctuationFst
from nemo_text_processing.inverse_text_normalization.en.taggers.word import WordFst
from nemo_text_processing.inverse_text_normalization.ru.taggers.cardinal import CardinalFst
from nemo_text_processing.inverse_text_normalization.ru.taggers.date import DateFst
from nemo_text_processing.inverse_text_normalization.ru.taggers.decimals import DecimalFst
from nemo_text_processing.inverse_text_normalization.ru.taggers.electronic import ElectronicFst
from nemo_text_processing.inverse_text_normalization.ru.taggers.measure import MeasureFst
from nemo_text_processing.inverse_text_normalization.ru.taggers.money import MoneyFst
from nemo_text_processing.inverse_text_normalization.ru.taggers.ordinal import OrdinalFst
from nemo_text_processing.inverse_text_normalization.ru.taggers.telephone import TelephoneFst
from nemo_text_processing.inverse_text_normalization.ru.taggers.time import TimeFst
from nemo_text_processing.inverse_text_normalization.ru.taggers.whitelist import WhiteListFst
from nemo_text_processing.text_normalization.en.graph_utils import (
INPUT_LOWER_CASED,
GraphFst,
delete_extra_space,
delete_space,
generator_main,
)
from nemo_text_processing.text_normalization.ru.taggers.tokenize_and_classify import ClassifyFst as TNClassifyFst
from pynini.lib import pynutil
class ClassifyFst(GraphFst):
"""
Final class that composes all other classification grammars. This class can process an entire sentence, that is lower cased.
For deployment, this grammar will be compiled and exported to OpenFst Finite State Archive (FAR) File.
More details to deployment at NeMo/tools/text_processing_deployment.
Args:
cache_dir: path to a dir with .far grammar file. Set to None to avoid using cache.
overwrite_cache: set to True to overwrite .far files
whitelist: path to a file with whitelist replacements
input_case: accepting either "lower_cased" or "cased" input.
"""
def __init__(
self,
cache_dir: str = None,
overwrite_cache: bool = False,
whitelist: str = None,
input_case: str = INPUT_LOWER_CASED,
):
super().__init__(name="tokenize_and_classify", kind="classify")
far_file = None
if cache_dir is not None and cache_dir != "None":
os.makedirs(cache_dir, exist_ok=True)
far_file = os.path.join(cache_dir, f"ru_itn_{input_case}.far")
if not overwrite_cache and far_file and os.path.exists(far_file):
self.fst = pynini.Far(far_file, mode="r")["tokenize_and_classify"]
logging.info(f"ClassifyFst.fst was restored from {far_file}.")
else:
logging.info(f"Creating ClassifyFst grammars. This might take some time...")
tn_classify = TNClassifyFst(
input_case='cased', deterministic=False, cache_dir=cache_dir, overwrite_cache=True
)
cardinal = CardinalFst(tn_cardinal=tn_classify.cardinal)
cardinal_graph = cardinal.fst
ordinal = OrdinalFst(tn_ordinal=tn_classify.ordinal)
ordinal_graph = ordinal.fst
decimal = DecimalFst(tn_decimal=tn_classify.decimal)
decimal_graph = decimal.fst
measure_graph = MeasureFst(tn_measure=tn_classify.measure).fst
date_graph = DateFst(tn_date=tn_classify.date).fst
word_graph = WordFst().fst
time_graph = TimeFst(tn_time=tn_classify.time).fst
money_graph = MoneyFst(tn_money=tn_classify.money).fst
whitelist_graph = WhiteListFst(input_file=whitelist).fst
punct_graph = PunctuationFst().fst
electronic_graph = ElectronicFst(tn_electronic=tn_classify.electronic).fst
telephone_graph = TelephoneFst(tn_telephone=tn_classify.telephone).fst
classify = (
pynutil.add_weight(whitelist_graph, 1.01)
| pynutil.add_weight(time_graph, 1.1)
| pynutil.add_weight(date_graph, 1.09)
| pynutil.add_weight(decimal_graph, 1.1)
| pynutil.add_weight(measure_graph, 1.1)
| pynutil.add_weight(ordinal_graph, 1.1)
| pynutil.add_weight(money_graph, 1.1)
| pynutil.add_weight(telephone_graph, 1.1)
| pynutil.add_weight(electronic_graph, 1.1)
| pynutil.add_weight(cardinal_graph, 1.1)
| pynutil.add_weight(word_graph, 100)
)
punct = pynutil.insert("tokens { ") + pynutil.add_weight(punct_graph, weight=1.1) + pynutil.insert(" }")
token = pynutil.insert("tokens { ") + classify + pynutil.insert(" }")
token_plus_punct = (
pynini.closure(punct + pynutil.insert(" ")) + token + pynini.closure(pynutil.insert(" ") + punct)
)
graph = token_plus_punct + pynini.closure(pynutil.add_weight(delete_extra_space, 1.1) + token_plus_punct)
graph = delete_space + graph + delete_space
self.fst = graph.optimize()
if far_file:
generator_main(far_file, {"tokenize_and_classify": self.fst})
logging.info(f"ClassifyFst grammars are saved to {far_file}.")
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/tokenize_and_classify.py |
# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/__init__.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst
from pynini.lib import pynutil
class MoneyFst(GraphFst):
"""
Finite state transducer for classifying money, e.g.
"два рубля" -> money { integer_part: "2 руб." }
Args:
tn_money: Text normalization Money graph
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, tn_money, deterministic: bool = True):
super().__init__(name="money", kind="classify", deterministic=deterministic)
graph = tn_money.final_graph
graph = graph.invert().optimize()
graph = pynutil.insert("integer_part: \"") + graph + pynutil.insert("\"")
graph = self.add_tokens(graph)
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/money.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_DIGIT, GraphFst, insert_space
from pynini.lib import pynutil
class CardinalFst(GraphFst):
"""
Finite state transducer for classifying cardinals, e.g.
"тысяча один" -> cardinal { integer: "1 001" }
Args:
tn_cardinal: Text normalization Cardinal graph
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, tn_cardinal: GraphFst, deterministic: bool = True):
super().__init__(name="cardinal", kind="classify", deterministic=deterministic)
graph = tn_cardinal.cardinal_numbers_default
self.graph = graph.invert().optimize()
optional_sign = pynini.closure(
pynutil.insert("negative: ") + pynini.cross("минус ", "\"-\"") + insert_space, 0, 1
)
# do not invert numbers less than 10
graph = pynini.compose(graph, NEMO_DIGIT ** (2, ...))
graph = optional_sign + pynutil.insert("integer: \"") + graph + pynutil.insert("\"")
graph = self.add_tokens(graph)
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/cardinal.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_SPACE, GraphFst, delete_extra_space
from pynini.lib import pynutil
class DecimalFst(GraphFst):
"""
Finite state transducer for classifying decimal
e.g. "минус три целых две десятых" -> decimal { negative: "true" integer_part: "3," fractional_part: "2" }
Args:
tn_decimal: Text normalization Decimal graph
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, tn_decimal, deterministic: bool = False):
super().__init__(name="decimal", kind="classify", deterministic=deterministic)
optional_graph_negative = pynini.closure(
pynutil.insert("negative: ") + pynini.cross("минус", "\"true\"") + delete_extra_space, 0, 1
)
graph_fractional_part = pynini.invert(tn_decimal.graph_fractional).optimize()
graph_integer_part = pynini.invert(tn_decimal.integer_part).optimize()
optional_graph_quantity = pynini.invert(tn_decimal.optional_quantity).optimize()
graph_fractional = pynutil.insert("fractional_part: \"") + graph_fractional_part + pynutil.insert("\"")
graph_integer = pynutil.insert("integer_part: \"") + graph_integer_part + pynutil.insert("\"")
optional_graph_quantity = pynutil.insert("quantity: \"") + optional_graph_quantity + pynutil.insert("\"")
optional_graph_quantity = pynini.closure(pynini.accep(NEMO_SPACE) + optional_graph_quantity, 0, 1)
self.final_graph_wo_sign = (
graph_integer + pynini.accep(NEMO_SPACE) + graph_fractional + optional_graph_quantity
)
final_graph = optional_graph_negative + self.final_graph_wo_sign
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/decimals.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst
from pynini.lib import pynutil
class ElectronicFst(GraphFst):
"""
Finite state transducer for classifying electronic, e.g.
"эй би собака эн ди точка ру" -> electronic { username: "[email protected]" }
Args:
tn_electronic: Text normalization Electronic graph
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, tn_electronic, deterministic: bool = True):
super().__init__(name="electronic", kind="classify", deterministic=deterministic)
graph = tn_electronic.final_graph
graph = graph.invert().optimize()
graph = pynutil.insert("username: \"") + graph + pynutil.insert("\"")
graph = self.add_tokens(graph)
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/electronic.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst
from pynini.lib import pynutil
class DateFst(GraphFst):
"""
Finite state transducer for classifying date, e.g.
восемнадцатое июня две тысячи второго -> tokens { date { day: "18.06.2002" } }
Args:
tn_date: Text normalization Date graph
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, tn_date: GraphFst, deterministic: bool = True):
super().__init__(name="date", kind="classify", deterministic=deterministic)
graph = pynini.invert(tn_date.final_graph).optimize()
graph = self.add_tokens(pynutil.insert("day: \"") + graph + pynutil.insert("\""))
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/taggers/date.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst, delete_space
from pynini.lib import pynutil
class TimeFst(GraphFst):
"""
Finite state transducer for verbalizing time
e.g. time { hours: "02:15" } -> "02:15"
"""
def __init__(self):
super().__init__(name="time", kind="verbalize")
hour = (
pynutil.delete("hours: ") + pynutil.delete("\"") + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete("\"")
)
minutes = (
pynutil.delete("minutes: ")
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
graph_preserve_order = pynutil.delete("hours: \"") + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete("\"")
# for cases that require permutations for the correct verbalization
graph_reverse_order = hour + delete_space + pynutil.insert(":") + minutes + delete_space
graph = graph_preserve_order | graph_reverse_order
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/time.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst, delete_space
from pynini.lib import pynutil
class MeasureFst(GraphFst):
"""
Finite state transducer for verbalizing measure
e.g. measure { cardinal { integer: "2 кг" } } -> "2 кг"
"""
def __init__(self):
super().__init__(name="measure", kind="verbalize")
graph = (
pynutil.delete(" cardinal { integer: \"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
+ delete_space
+ pynutil.delete("}")
)
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/measure.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst
from pynini.lib import pynutil
class TelephoneFst(GraphFst):
"""
Finite state transducer for verbalizing telephone
e.g. telephone { number_part: "8-913-983-56-01" } -> "8-913-983-56-01"
"""
def __init__(self):
super().__init__(name="telephone", kind="verbalize")
graph = pynutil.delete("number_part: \"") + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete("\"")
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/telephone.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst
from pynini.lib import pynutil
class OrdinalFst(GraphFst):
"""
Finite state transducer for verbalizing ordinal numbers
e.g. ordinal { integer: "2" } -> "2"
Args:
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, deterministic: bool = True):
super().__init__(name="ordinal", kind="verbalize", deterministic=deterministic)
value = pynini.closure(NEMO_NOT_QUOTE)
graph = pynutil.delete("integer: \"") + value + pynutil.delete("\"")
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/ordinal.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
from nemo_text_processing.inverse_text_normalization.en.verbalizers.whitelist import WhiteListFst
from nemo_text_processing.inverse_text_normalization.ru.verbalizers.cardinal import CardinalFst
from nemo_text_processing.inverse_text_normalization.ru.verbalizers.date import DateFst
from nemo_text_processing.inverse_text_normalization.ru.verbalizers.decimal import DecimalFst
from nemo_text_processing.inverse_text_normalization.ru.verbalizers.electronic import ElectronicFst
from nemo_text_processing.inverse_text_normalization.ru.verbalizers.measure import MeasureFst
from nemo_text_processing.inverse_text_normalization.ru.verbalizers.money import MoneyFst
from nemo_text_processing.inverse_text_normalization.ru.verbalizers.ordinal import OrdinalFst
from nemo_text_processing.inverse_text_normalization.ru.verbalizers.telephone import TelephoneFst
from nemo_text_processing.inverse_text_normalization.ru.verbalizers.time import TimeFst
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst
class VerbalizeFst(GraphFst):
"""
Composes other verbalizer grammars.
For deployment, this grammar will be compiled and exported to OpenFst Finite State Archive (FAR) File.
More details to deployment at NeMo/tools/text_processing_deployment.
"""
def __init__(self):
super().__init__(name="verbalize", kind="verbalize")
cardinal = CardinalFst()
cardinal_graph = cardinal.fst
ordinal = OrdinalFst()
ordinal_graph = ordinal.fst
decimal = DecimalFst()
decimal_graph = decimal.fst
whitelist_graph = WhiteListFst().fst
electronic_graph = ElectronicFst().fst
money_graph = MoneyFst().fst
date_graph = DateFst().fst
measure_graph = MeasureFst().fst
telephone_graph = TelephoneFst().fst
time_graph = TimeFst().fst
graph = (
whitelist_graph
| cardinal_graph
| ordinal_graph
| decimal_graph
| electronic_graph
| date_graph
| money_graph
| measure_graph
| telephone_graph
| time_graph
)
self.fst = graph
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/verbalize.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.en.verbalizers.word import WordFst
from nemo_text_processing.inverse_text_normalization.ru.verbalizers.verbalize import VerbalizeFst
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst, delete_extra_space, delete_space
from pynini.lib import pynutil
class VerbalizeFinalFst(GraphFst):
"""
Finite state transducer that verbalizes an entire sentence, e.g.
tokens { name: "its" } tokens { time { hours: "12" minutes: "30" } } tokens { name: "now" } -> its 12:30 now
"""
def __init__(self):
super().__init__(name="verbalize_final", kind="verbalize")
verbalize = VerbalizeFst().fst
word = WordFst().fst
types = verbalize | word
graph = (
pynutil.delete("tokens")
+ delete_space
+ pynutil.delete("{")
+ delete_space
+ types
+ delete_space
+ pynutil.delete("}")
)
graph = delete_space + pynini.closure(graph + delete_extra_space) + graph + delete_space
self.fst = graph
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/verbalize_final.py |
# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/__init__.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, NEMO_SPACE, GraphFst, delete_space
from pynini.lib import pynutil
class DecimalFst(GraphFst):
"""
Finite state transducer for verbalizing decimal, e.g.
decimal { negative: "true" integer_part: "3," fractional_part: "2" } -> -3,2
Args:
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, deterministic: bool = True):
super().__init__(name="decimal", kind="verbalize", deterministic=deterministic)
optional_sign = pynini.closure(pynini.cross("negative: \"true\" ", "-"), 0, 1)
integer = pynutil.delete(" \"") + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete("\"")
integer_part = pynutil.delete("integer_part:") + integer
fractional_part = pynutil.delete("fractional_part:") + integer
optional_quantity = pynini.closure(pynini.accep(NEMO_SPACE) + pynutil.delete("quantity:") + integer, 0, 1)
graph = optional_sign + integer_part + delete_space + fractional_part + optional_quantity
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/decimal.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst
from pynini.lib import pynutil
class MoneyFst(GraphFst):
"""
Finite state transducer for verbalizing electronic
e.g. money { integer_part: "2 руб." } -> "2 руб."
"""
def __init__(self):
super().__init__(name="money", kind="verbalize")
graph = pynutil.delete("integer_part: \"") + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete("\"")
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/money.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst, delete_space
from pynini.lib import pynutil
class CardinalFst(GraphFst):
"""
Finite state transducer for verbalizing roman numerals
e.g. cardinal { integer: "1 001" } -> 1 001
Args:
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, deterministic: bool = True):
super().__init__(name="cardinal", kind="verbalize", deterministic=deterministic)
optional_sign = pynini.closure(
pynutil.delete("negative:")
+ delete_space
+ pynutil.delete("\"")
+ NEMO_NOT_QUOTE
+ pynutil.delete("\"")
+ delete_space,
0,
1,
)
graph = (
optional_sign + pynutil.delete("integer: \"") + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete("\"")
)
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/cardinal.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst
from pynini.lib import pynutil
class ElectronicFst(GraphFst):
"""
Finite state transducer for verbalizing electronic
e.g. electronic { username: "[email protected]" } -> "[email protected]"
"""
def __init__(self):
super().__init__(name="electronic", kind="verbalize")
graph = pynutil.delete("username: \"") + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete("\"")
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/electronic.py |
# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst
from pynini.lib import pynutil
class DateFst(GraphFst):
"""
Finite state transducer for verbalizing date, e.g.
date { day: "02.03.89" } -> "02.03.89"
"""
def __init__(self):
super().__init__(name="date", kind="verbalize")
graph = pynutil.delete("day: \"") + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete("\"")
delete_tokens = self.delete_tokens(graph.optimize())
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ru/verbalizers/date.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
from nemo_text_processing.inverse_text_normalization.pt.taggers.tokenize_and_classify import ClassifyFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.verbalize import VerbalizeFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.verbalize_final import VerbalizeFinalFst
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/__init__.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import os
def get_abs_path(rel_path):
"""
Get absolute path
Args:
rel_path: relative path to this file
Returns absolute path
"""
return os.path.dirname(os.path.abspath(__file__)) + '/' + rel_path
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/utils.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.utils import get_abs_path
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst, delete_space, insert_space
from pynini.lib import pynutil
class TimeFst(GraphFst):
"""
Finite state transducer for classifying time
e.g. quinze pro meio dia -> time { hours: "11" minutes: "45" }
e.g. quinze pra meia noite -> time { hours: "23" minutes: "45" }
e.g. quinze pra uma -> time { hours: "12" minutes: "45" }
e.g. dez pras duas -> time { hours: "1" minutes: "50" }
e.g. quinze pras duas -> time { hours: "1" minutes: "45" }
e.g. ao meio dia -> time { hours: "12" minutes: "00" morphosyntactic_features: "ao" }
e.g. ao meio dia e meia -> time { hours: "12" minutes: "30" morphosyntactic_features: "ao" }
e.g. ao meio dia e meio -> time { hours: "12" minutes: "30" morphosyntactic_features: "ao" }
e.g. à meia noite e quinze -> time { hours: "0" minutes: "15" morphosyntactic_features: "à" }
e.g. à meia noite e meia -> time { hours: "0" minutes: "30" morphosyntactic_features: "à" }
e.g. à uma e trinta -> time { hours: "1" minutes: "30" morphosyntactic_features: "à" }
e.g. às onze e trinta -> time { hours: "11" minutes: "30" morphosyntactic_features: "às" }
e.g. às três horas e trinta minutos -> time { hours: "3" minutes: "30" morphosyntactic_features: "às" }
"""
def __init__(self):
super().__init__(name="time", kind="classify")
# graph_hour_to_am = pynini.string_file(get_abs_path("data/time/hour_to_am.tsv"))
# graph_hour_to_pm = pynini.string_file(get_abs_path("data/time/hour_to_pm.tsv"))
graph_hours_to = pynini.string_file(get_abs_path("data/time/hours_to.tsv"))
graph_minutes_to = pynini.string_file(get_abs_path("data/time/minutes_to.tsv"))
graph_suffix_am = pynini.string_file(get_abs_path("data/time/time_suffix_am.tsv"))
graph_suffix_pm = pynini.string_file(get_abs_path("data/time/time_suffix_pm.tsv"))
graph_digit = pynini.string_file(get_abs_path("data/numbers/digit.tsv"))
graph_ties = pynini.string_file(get_abs_path("data/numbers/ties.tsv"))
graph_teen = pynini.string_file(get_abs_path("data/numbers/teen.tsv"))
graph_twenties = pynini.string_file(get_abs_path("data/numbers/twenties.tsv"))
graph_1_to_100 = pynini.union(
graph_digit,
graph_twenties,
graph_teen,
(graph_ties + pynutil.insert("0")),
(graph_ties + pynutil.delete(" e ") + graph_digit),
)
# note that graph_hour will start from 2 hours
# "1 o'clock" will be treated differently because it
# is singular
digits_2_to_23 = [str(digits) for digits in range(2, 24)]
digits_1_to_59 = [str(digits) for digits in range(1, 60)]
graph_2_to_23 = graph_1_to_100 @ pynini.union(*digits_2_to_23)
graph_1_to_59 = graph_1_to_100 @ pynini.union(*digits_1_to_59)
graph_uma = pynini.cross("uma", "1")
# Mapping 'horas'
graph_hour = pynutil.delete(pynini.accep("hora") + pynini.accep("s").ques)
graph_minute = pynutil.delete(pynini.accep("minuto") + pynini.accep("s").ques)
# Mapping 'meio dia' and 'meia noite'
graph_meio_dia = pynini.cross("meio dia", "12")
graph_meia_noite = pynini.cross("meia noite", "0")
# Mapping 'e meia'
graph_e = delete_space + pynutil.delete(" e ") + delete_space
graph_e_meia = graph_e + pynini.cross("meia", "30")
graph_e_meio = graph_e + pynini.cross("meio", "30")
# à uma e meia -> 1:30
# às três e meia -> 3:30
graph_hours_at_prefix_singular = (
pynutil.insert("morphosyntactic_features: \"")
+ (pynini.cross("à", "à") | pynini.cross("a", "à"))
+ pynutil.insert("\" ")
+ delete_space
)
graph_hours_at_singular = (
graph_hours_at_prefix_singular
+ pynutil.insert("hours: \"")
+ graph_uma
+ pynutil.insert("\"")
+ (delete_space + graph_hour).ques
)
graph_hours_at_prefix_plural = (
pynutil.insert("morphosyntactic_features: \"")
+ (pynini.cross("às", "às") | pynini.cross("as", "às"))
+ pynutil.insert("\" ")
+ delete_space
)
graph_hours_at_plural = (
graph_hours_at_prefix_plural
+ pynutil.insert("hours: \"")
+ graph_2_to_23
+ pynutil.insert("\"")
+ (delete_space + graph_hour).ques
)
final_graph_hour_at = graph_hours_at_singular | graph_hours_at_plural
graph_minutes_component_without_zero = graph_e + graph_1_to_59 + (delete_space + graph_minute).ques
graph_minutes_component_without_zero |= graph_e_meia + pynutil.delete(delete_space + pynini.accep("hora")).ques
final_graph_minute = (
pynutil.insert(" minutes: \"") + graph_minutes_component_without_zero + pynutil.insert("\"")
)
graph_hm = final_graph_hour_at + final_graph_minute
# à uma hora -> 1:00
graph_hours_at_singular_with_hour = (
graph_hours_at_prefix_singular
+ pynutil.insert("hours: \"")
+ graph_uma
+ pynutil.insert("\"")
+ delete_space
+ graph_hour
)
graph_hours_at_plural_with_hour = (
graph_hours_at_prefix_plural
+ pynutil.insert("hours: \"")
+ graph_2_to_23
+ pynutil.insert("\"")
+ delete_space
+ graph_hour
)
graph_hm |= (graph_hours_at_singular_with_hour | graph_hours_at_plural_with_hour) + pynutil.insert(
" minutes: \"00\"", weight=0.2
)
# meio dia e meia -> 12:30
# meia noite e meia -> 0:30
graph_minutes_without_zero = (
pynutil.insert(" minutes: \"") + graph_minutes_component_without_zero + pynutil.insert("\"")
)
graph_meio_min = (
pynutil.insert("hours: \"")
+ (graph_meio_dia | graph_meia_noite)
+ pynutil.insert("\"")
+ graph_minutes_without_zero
)
graph_meio_min |= (
pynutil.insert("hours: \"")
+ graph_meio_dia
+ pynutil.insert("\" minutes: \"")
+ graph_e_meio
+ pynutil.insert("\"")
)
graph_hm |= graph_meio_min
# às quinze para as quatro -> às 3:45
# NOTE: case 'para à uma' ('to one') could be either 0:XX or 12:XX
# leading to wrong reading ('meio dia e ...' or 'meia noite e ...')
graph_para_a = (
pynutil.delete("para")
| pynutil.delete("para a")
| pynutil.delete("para as")
| pynutil.delete("pra")
| pynutil.delete("pras")
)
graph_para_o = pynutil.delete("para") | pynutil.delete("para o") | pynutil.delete("pro")
graph_pra_min = (
pynutil.insert("morphosyntactic_features: \"")
+ (pynini.cross("à", "à") | pynini.cross("às", "às") | pynini.cross("a", "à") | pynini.cross("as", "às"))
+ pynutil.insert("\" ")
+ delete_space
)
graph_pra_min += (
pynutil.insert("minutes: \"")
+ (graph_1_to_59 @ graph_minutes_to)
+ pynutil.insert("\" ")
+ (delete_space + graph_minute).ques
)
graph_pra_hour = (
pynutil.insert("hours: \"")
+ (graph_2_to_23 @ graph_hours_to)
+ pynutil.insert("\"")
+ (delete_space + graph_hour).ques
)
graph_pra_hour |= pynutil.insert("hours: \"") + (graph_meia_noite @ graph_hours_to) + pynutil.insert("\"")
graph_pra = graph_pra_min + delete_space + graph_para_a + delete_space + graph_pra_hour
# às quinze pro meio dia -> às 11:45
graph_pro = graph_pra_min + delete_space + graph_para_o + delete_space
graph_pro += pynutil.insert(" hours: \"") + (graph_meio_dia @ graph_hours_to) + pynutil.insert("\"")
graph_mh = graph_pra | graph_pro
# optional suffix
final_suffix = pynutil.insert("suffix: \"") + (graph_suffix_am | graph_suffix_pm) + pynutil.insert("\"")
final_suffix_optional = pynini.closure(delete_space + insert_space + final_suffix, 0, 1)
final_graph = pynini.union((graph_hm | graph_mh) + final_suffix_optional).optimize()
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/time.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.utils import get_abs_path
from nemo_text_processing.text_normalization.en.graph_utils import (
NEMO_SIGMA,
GraphFst,
convert_space,
delete_extra_space,
delete_space,
)
from pynini.lib import pynutil
class MeasureFst(GraphFst):
"""
Finite state transducer for classifying measure
e.g. menos doze quilogramas -> measure { cardinal { negative: "true" integer: "12" } units: "kg" }
Args:
cardinal: CardinalFst
decimal: DecimalFst
"""
def __init__(self, cardinal: GraphFst, decimal: GraphFst):
super().__init__(name="measure", kind="classify")
cardinal_graph = cardinal.graph_no_exception
graph_unit_singular = pynini.string_file(get_abs_path("data/measurements_singular.tsv")).invert()
graph_unit_plural = pynini.string_file(get_abs_path("data/measurements_plural.tsv")).invert()
optional_graph_negative = pynini.closure(
pynutil.insert("negative: ") + pynini.cross("menos", "\"true\"") + delete_extra_space, 0, 1
)
unit_singular = convert_space(graph_unit_singular)
unit_plural = convert_space(graph_unit_plural)
unit_misc = pynutil.insert("/") + pynutil.delete("por") + delete_space + convert_space(graph_unit_singular)
unit_singular = (
pynutil.insert("units: \"")
+ (unit_singular | unit_misc | pynutil.add_weight(unit_singular + delete_space + unit_misc, 0.01))
+ pynutil.insert("\"")
)
unit_plural = (
pynutil.insert("units: \"")
+ (unit_plural | unit_misc | pynutil.add_weight(unit_plural + delete_space + unit_misc, 0.01))
+ pynutil.insert("\"")
)
subgraph_decimal = (
pynutil.insert("decimal { ")
+ optional_graph_negative
+ decimal.final_graph_wo_negative
+ pynutil.insert(" }")
+ delete_extra_space
+ unit_plural
)
subgraph_cardinal = (
pynutil.insert("cardinal { ")
+ optional_graph_negative
+ pynutil.insert("integer: \"")
+ ((NEMO_SIGMA - "um" - "uma") @ cardinal_graph)
+ pynutil.insert("\"")
+ pynutil.insert(" }")
+ delete_extra_space
+ unit_plural
)
subgraph_cardinal |= (
pynutil.insert("cardinal { ")
+ optional_graph_negative
+ pynutil.insert("integer: \"")
+ (pynini.cross("um", "1") | pynini.cross("uma", "1"))
+ pynutil.insert("\"")
+ pynutil.insert(" }")
+ delete_extra_space
+ unit_singular
)
final_graph = subgraph_decimal | subgraph_cardinal
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/measure.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.utils import get_abs_path
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst, delete_space, insert_space
from pynini.lib import pynutil
class TelephoneFst(GraphFst):
"""
Finite state transducer for classifying telephone numbers, e.g.
um dois um dois três quatro cinco seis sete oito nove -> { number_part: "(12) 12345-6789" }.
If 11 digits are spoken, they are grouped as 2+5+4 (eg. (12) 34567-8901).
If 10 digits are spoken, they are grouped as 2+4+4 (eg. (12) 3456-7890).
If 9 digits are spoken, they are grouped as 5+4 (eg. 12345-6789).
If 8 digits are spoken, they are grouped as 4+4 (eg. 1234-5678).
In portuguese, digits are generally spoken individually, or as 2-digit numbers,
eg. "trinta e quatro oitenta e dois" = "3482",
"meia sete vinte" = "6720".
"""
def __init__(self):
super().__init__(name="telephone", kind="classify")
# create `single_digits` and `double_digits` graphs as these will be
# the building blocks of possible telephone numbers
graph_digit = pynini.string_file(get_abs_path("data/numbers/digit.tsv"))
graph_ties = pynini.string_file(get_abs_path("data/numbers/ties.tsv"))
graph_twenties = pynini.string_file(get_abs_path("data/numbers/twenties.tsv"))
graph_teen = pynini.string_file(get_abs_path("data/numbers/teen.tsv"))
graph_zero = pynini.string_file(get_abs_path("data/numbers/zero.tsv"))
graph_half = pynini.cross("meia", "6")
graph_all_digits = pynini.union(graph_digit, graph_half, graph_zero)
single_digits = pynini.invert(graph_all_digits).optimize()
double_digits = (
pynini.union(
graph_teen | graph_twenties,
(graph_ties + pynutil.insert("0")),
(graph_ties + delete_space + pynutil.delete("e") + delete_space + graph_digit),
(graph_all_digits + delete_space + graph_all_digits),
)
.invert()
.optimize()
)
# define `eleven_digit_graph`, `ten_digit_graph`, `nine_digit_graph`, `eight_digit_graph`
# which accept telephone numbers spoken (1) only with single digits,
# or (2) spoken with double digits (and sometimes single digits)
# 11-digit option (2): (2) + (1+2+2) + (2+2) digits
eleven_digit_graph = (
pynutil.delete("(")
+ double_digits
+ insert_space
+ pynutil.delete(") ")
+ single_digits
+ insert_space
+ double_digits
+ insert_space
+ double_digits
+ insert_space
+ pynutil.delete("-")
+ double_digits
+ insert_space
+ double_digits
)
# 10-digit option (2): (2) + (2+2) + (2+2) digits
ten_digit_graph = (
pynutil.delete("(")
+ double_digits
+ insert_space
+ pynutil.delete(") ")
+ double_digits
+ insert_space
+ double_digits
+ insert_space
+ pynutil.delete("-")
+ double_digits
+ insert_space
+ double_digits
)
# 9-digit option (2): (1+2+2) + (2+2) digits
nine_digit_graph = (
single_digits
+ insert_space
+ double_digits
+ insert_space
+ double_digits
+ insert_space
+ pynutil.delete("-")
+ double_digits
+ insert_space
+ double_digits
)
# 8-digit option (2): (2+2) + (2+2) digits
eight_digit_graph = (
double_digits
+ insert_space
+ double_digits
+ insert_space
+ pynutil.delete("-")
+ double_digits
+ insert_space
+ double_digits
)
number_part = pynini.union(eleven_digit_graph, ten_digit_graph, nine_digit_graph, eight_digit_graph)
number_part = pynutil.insert("number_part: \"") + pynini.invert(number_part) + pynutil.insert("\"")
graph = number_part
final_graph = self.add_tokens(graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/telephone.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.utils import get_abs_path
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_SIGMA, GraphFst, delete_space
from pynini.lib import pynutil
class OrdinalFst(GraphFst):
"""
Finite state transducer for classifying ordinal
vigésimo primeiro -> ordinal { integer: "21" morphosyntactic_features: "o" }
This class converts ordinal up to "milésimo" (one thousandth) exclusive.
Cardinals below ten are not converted (in order to avoid
e.g. "primero fez ..." -> "1º fez...", "segunda guerra mundial" -> "2ª guerra mundial"
and any other odd conversions.)
This FST also records the ending of the ordinal (called "morphosyntactic_features"):
either "o" or "a".
Args:
cardinal: CardinalFst
"""
def __init__(self):
super().__init__(name="ordinal", kind="classify")
graph_digit = pynini.string_file(get_abs_path("data/ordinals/digit.tsv"))
graph_ties = pynini.string_file(get_abs_path("data/ordinals/ties.tsv"))
graph_hundreds = pynini.string_file(get_abs_path("data/ordinals/hundreds.tsv"))
ordinal_graph_union = pynini.union(
pynutil.add_weight(graph_digit, 0.4),
pynutil.add_weight(graph_ties + ((delete_space + graph_digit) | pynutil.insert("0")), 0.2),
graph_hundreds
+ ((delete_space + graph_ties) | pynutil.insert("0"))
+ ((delete_space + graph_digit) | pynutil.insert("0")),
)
accept_o_endings = NEMO_SIGMA + pynini.accep("o")
accept_a_endings = NEMO_SIGMA + pynini.accep("a")
ordinal_graph_o = accept_o_endings @ ordinal_graph_union
ordinal_graph_a = accept_a_endings @ ordinal_graph_union
# 'optional_numbers_in_front' have negative weight so we always
# include them if they're there
optional_in_front = (pynutil.add_weight(ordinal_graph_union, -0.1) + delete_space.closure()).closure()
graph_o_suffix = optional_in_front + ordinal_graph_o
graph_a_suffix = optional_in_front + ordinal_graph_a
# don't convert ordinals from one to nine inclusive
graph_exception = pynini.project(pynini.union(graph_digit), 'input')
graph_o_suffix = (pynini.project(graph_o_suffix, "input") - graph_exception.arcsort()) @ graph_o_suffix
graph_a_suffix = (pynini.project(graph_a_suffix, "input") - graph_exception.arcsort()) @ graph_a_suffix
graph = (
pynutil.insert("integer: \"")
+ graph_o_suffix
+ pynutil.insert("\"")
+ pynutil.insert(" morphosyntactic_features: \"o\"")
)
graph |= (
pynutil.insert("integer: \"")
+ graph_a_suffix
+ pynutil.insert("\"")
+ pynutil.insert(" morphosyntactic_features: \"a\"")
)
final_graph = self.add_tokens(graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/ordinal.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.utils import get_abs_path
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst, convert_space
from pynini.lib import pynutil
class WhiteListFst(GraphFst):
"""
Finite state transducer for classifying whitelisted tokens
e.g. usted -> tokens { name: "ud." }
This class has highest priority among all classifier grammars.
Whitelisted tokens are defined and loaded from "data/whitelist.tsv" (unless input_file specified).
Args:
input_file: path to a file with whitelist replacements (each line of the file: written_form\tspoken_form\n),
e.g. nemo_text_processing/inverse_text_normalization/pt/data/whitelist.tsv
"""
def __init__(self, input_file: str = None):
super().__init__(name="whitelist", kind="classify")
if input_file:
whitelist = pynini.string_file(input_file).invert()
else:
whitelist = pynini.string_file(get_abs_path("data/whitelist.tsv")).invert()
graph = pynutil.insert("name: \"") + convert_space(whitelist) + pynutil.insert("\"")
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/whitelist.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import logging
import os
import pynini
from nemo_text_processing.inverse_text_normalization.pt.taggers.cardinal import CardinalFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.date import DateFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.decimal import DecimalFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.electronic import ElectronicFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.measure import MeasureFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.money import MoneyFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.ordinal import OrdinalFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.punctuation import PunctuationFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.telephone import TelephoneFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.time import TimeFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.whitelist import WhiteListFst
from nemo_text_processing.inverse_text_normalization.pt.taggers.word import WordFst
from nemo_text_processing.text_normalization.en.graph_utils import (
INPUT_LOWER_CASED,
GraphFst,
delete_extra_space,
delete_space,
generator_main,
)
from pynini.lib import pynutil
class ClassifyFst(GraphFst):
"""
Final class that composes all other classification grammars. This class can process an entire sentence, that is lower cased.
For deployment, this grammar will be compiled and exported to OpenFst Finite State Archive (FAR) File.
More details to deployment at NeMo/tools/text_processing_deployment.
Args:
cache_dir: path to a dir with .far grammar file. Set to None to avoid using cache.
overwrite_cache: set to True to overwrite .far files
whitelist: path to a file with whitelist replacements
input_case: accepting either "lower_cased" or "cased" input.
"""
def __init__(
self,
cache_dir: str = None,
overwrite_cache: bool = False,
whitelist: str = None,
input_case: str = INPUT_LOWER_CASED,
):
super().__init__(name="tokenize_and_classify", kind="classify")
far_file = None
if cache_dir is not None and cache_dir != "None":
os.makedirs(cache_dir, exist_ok=True)
far_file = os.path.join(cache_dir, f"pt_itn_{input_case}.far")
if not overwrite_cache and far_file and os.path.exists(far_file):
self.fst = pynini.Far(far_file, mode="r")["tokenize_and_classify"]
logging.info(f"ClassifyFst.fst was restored from {far_file}.")
else:
logging.info(f"Creating ClassifyFst grammars.")
cardinal = CardinalFst(use_strict_e=True)
cardinal_graph = cardinal.fst
ordinal_graph = OrdinalFst().fst
decimal = DecimalFst(cardinal)
decimal_graph = decimal.fst
measure_graph = MeasureFst(cardinal=cardinal, decimal=decimal).fst
date_graph = DateFst(cardinal=cardinal).fst
word_graph = WordFst().fst
time_graph = TimeFst().fst
money_graph = MoneyFst(cardinal=cardinal, decimal=decimal).fst
whitelist_graph = WhiteListFst(input_file=whitelist).fst
punct_graph = PunctuationFst().fst
electronic_graph = ElectronicFst().fst
telephone_graph = TelephoneFst().fst
classify = (
pynutil.add_weight(whitelist_graph, 1.01)
| pynutil.add_weight(time_graph, 1.09)
| pynutil.add_weight(date_graph, 1.09)
| pynutil.add_weight(decimal_graph, 1.09)
| pynutil.add_weight(measure_graph, 1.1)
| pynutil.add_weight(cardinal_graph, 1.1)
| pynutil.add_weight(ordinal_graph, 1.1)
| pynutil.add_weight(money_graph, 1.1)
| pynutil.add_weight(telephone_graph, 1.1)
| pynutil.add_weight(electronic_graph, 1.1)
| pynutil.add_weight(word_graph, 100)
)
punct = pynutil.insert("tokens { ") + pynutil.add_weight(punct_graph, weight=1.1) + pynutil.insert(" }")
token = pynutil.insert("tokens { ") + classify + pynutil.insert(" }")
token_plus_punct = (
pynini.closure(punct + pynutil.insert(" ")) + token + pynini.closure(pynutil.insert(" ") + punct)
)
graph = token_plus_punct + pynini.closure(delete_extra_space + token_plus_punct)
graph = delete_space + graph + delete_space
self.fst = graph.optimize()
if far_file:
generator_main(far_file, {"tokenize_and_classify": self.fst})
logging.info(f"ClassifyFst grammars are saved to {far_file}.")
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/tokenize_and_classify.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst
from pynini.lib import pynutil
class PunctuationFst(GraphFst):
"""
Finite state transducer for classifying punctuation
e.g. a, -> tokens { name: "a" } tokens { name: "," }
"""
def __init__(self):
super().__init__(name="punctuation", kind="classify")
s = "!#$%&\'()*+,-./:;<=>?@^_`{|}~"
punct = pynini.union(*s)
graph = pynutil.insert("name: \"") + punct + pynutil.insert("\"")
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/punctuation.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/__init__.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.utils import get_abs_path
from nemo_text_processing.text_normalization.en.graph_utils import (
NEMO_DIGIT,
GraphFst,
delete_extra_space,
delete_space,
)
from pynini.lib import pynutil
def get_quantity(decimal: 'pynini.FstLike', cardinal_up_to_million: 'pynini.FstLike') -> 'pynini.FstLike':
"""
Returns FST that transforms either a cardinal or decimal followed by a quantity into a numeral,
e.g. one million -> integer_part: "1" quantity: "million"
e.g. one point five million -> integer_part: "1" fractional_part: "5" quantity: "million"
Args:
decimal: decimal FST
cardinal_up_to_million: cardinal FST
"""
numbers = cardinal_up_to_million @ (
pynutil.delete(pynini.closure("0")) + pynini.difference(NEMO_DIGIT, "0") + pynini.closure(NEMO_DIGIT)
)
suffix = pynini.union(
"milhão",
"milhões",
"bilhão",
"bilhões",
"trilhão",
"trilhões",
"quatrilhão",
"quatrilhões",
"quintilhão",
"quintilhões",
"sextilhão",
"sextilhões",
)
res = (
pynutil.insert("integer_part: \"")
+ numbers
+ pynutil.insert("\"")
+ delete_extra_space
+ pynutil.insert("quantity: \"")
+ suffix
+ pynutil.insert("\"")
)
res |= decimal + delete_extra_space + pynutil.insert("quantity: \"") + suffix + pynutil.insert("\"")
return res
class DecimalFst(GraphFst):
"""
Finite state transducer for classifying decimal
Decimal point is either "." or ",", determined by whether "ponto" or "vírgula" is spoken.
e.g. menos um vírgula dois seis -> decimal { negative: "true" integer_part: "1" morphosyntactic_features: "," fractional_part: "26" }
e.g. menos um ponto dois seis -> decimal { negative: "true" integer_part: "1" morphosyntactic_features: "." fractional_part: "26" }
This decimal rule assumes that decimals can be pronounced as:
(a cardinal) + ('vírgula' or 'ponto') plus (any sequence of cardinals <1000, including 'zero')
Also writes large numbers in shortened form, e.g.
e.g. um vírgula dois seis milhões -> decimal { negative: "false" integer_part: "1" morphosyntactic_features: "," fractional_part: "26" quantity: "milhões" }
e.g. dois milhões -> decimal { negative: "false" integer_part: "2" quantity: "milhões" }
e.g. mil oitcentos e vinte e quatro milhões -> decimal { negative: "false" integer_part: "1824" quantity: "milhões" }
Args:
cardinal: CardinalFst
"""
def __init__(self, cardinal: GraphFst):
super().__init__(name="decimal", kind="classify")
# number after decimal point can be any series of cardinals <1000, including 'zero'
graph_decimal = cardinal.numbers_up_to_thousand
graph_decimal = pynini.closure(graph_decimal + delete_space) + graph_decimal
self.graph = graph_decimal
# decimal point can be denoted by 'vírgula' or 'ponto'
decimal_point = pynini.cross("vírgula", "morphosyntactic_features: \",\"")
decimal_point |= pynini.cross("ponto", "morphosyntactic_features: \".\"")
optional_graph_negative = pynini.closure(
pynutil.insert("negative: ") + pynini.cross("menos", "\"true\"") + delete_extra_space, 0, 1
)
graph_fractional = pynutil.insert("fractional_part: \"") + graph_decimal + pynutil.insert("\"")
cardinal_graph = cardinal.graph_no_exception | pynini.string_file(get_abs_path("data/numbers/zero.tsv"))
graph_integer = pynutil.insert("integer_part: \"") + cardinal_graph + pynutil.insert("\"")
final_graph_wo_sign = (
pynini.closure(graph_integer + delete_extra_space, 0, 1)
+ decimal_point
+ delete_extra_space
+ graph_fractional
)
final_graph = optional_graph_negative + final_graph_wo_sign
self.final_graph_wo_negative = final_graph_wo_sign | get_quantity(
final_graph_wo_sign, cardinal.numbers_up_to_million
)
final_graph |= optional_graph_negative + get_quantity(final_graph_wo_sign, cardinal.numbers_up_to_million)
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/decimal.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.utils import get_abs_path
from nemo_text_processing.text_normalization.en.graph_utils import (
NEMO_DIGIT,
NEMO_SIGMA,
GraphFst,
convert_space,
delete_extra_space,
delete_space,
insert_space,
)
from pynini.lib import pynutil
class MoneyFst(GraphFst):
"""
Finite state transducer for classifying money
e.g. doze dólares e cinco centavos -> money { integer_part: "12" fractional_part: "05" currency: "$" }
Args:
cardinal: CardinalFst
decimal: DecimalFst
"""
def __init__(self, cardinal: GraphFst, decimal: GraphFst):
super().__init__(name="money", kind="classify")
# quantity, integer_part, fractional_part, currency
cardinal_graph = cardinal.graph_no_exception
graph_decimal_final = decimal.final_graph_wo_negative
unit_singular = pynini.string_file(get_abs_path("data/currency_singular.tsv")).invert()
unit_plural = pynini.string_file(get_abs_path("data/currency_plural.tsv")).invert()
graph_unit_singular = pynutil.insert("currency: \"") + convert_space(unit_singular) + pynutil.insert("\"")
graph_unit_plural = pynutil.insert("currency: \"") + convert_space(unit_plural) + pynutil.insert("\"")
add_leading_zero_to_double_digit = (NEMO_DIGIT + NEMO_DIGIT) | (pynutil.insert("0") + NEMO_DIGIT)
# twelve dollars (and) fifty cents, zero cents
cents_standalone = (
pynutil.insert("morphosyntactic_features: \",\"") # always use a comma in the decimal
+ insert_space
+ pynutil.insert("fractional_part: \"")
+ pynini.union(
pynutil.add_weight(((NEMO_SIGMA - "um" - "uma") @ cardinal_graph), -0.7)
@ add_leading_zero_to_double_digit
+ delete_space
+ pynutil.delete(pynini.union("centavos")),
pynini.cross("um", "01") + delete_space + pynutil.delete(pynini.union("centavo")),
)
+ pynutil.insert("\"")
)
optional_cents_standalone = pynini.closure(
delete_space
+ pynini.closure((pynutil.delete("com") | pynutil.delete('e')) + delete_space, 0, 1)
+ insert_space
+ cents_standalone,
0,
1,
)
# twelve dollars fifty, only after integer
# setenta e cinco dólares com sessenta e três ~ $75,63
optional_cents_suffix = pynini.closure(
delete_extra_space
+ pynutil.insert("morphosyntactic_features: \",\"") # always use a comma in the decimal
+ insert_space
+ pynutil.insert("fractional_part: \"")
+ pynini.closure((pynutil.delete("com") | pynutil.delete('e')) + delete_space, 0, 1)
+ pynutil.add_weight(cardinal_graph @ add_leading_zero_to_double_digit, -0.7)
+ pynutil.insert("\""),
0,
1,
)
graph_integer = (
pynutil.insert("integer_part: \"")
+ ((NEMO_SIGMA - "um" - "uma") @ cardinal_graph)
+ pynutil.insert("\"")
+ delete_extra_space
+ graph_unit_plural
+ (optional_cents_standalone | optional_cents_suffix)
)
graph_integer |= (
pynutil.insert("integer_part: \"")
+ (pynini.cross("um", "1") | pynini.cross("uma", "1"))
+ pynutil.insert("\"")
+ delete_extra_space
+ graph_unit_singular
+ (optional_cents_standalone | optional_cents_suffix)
)
graph_cents_standalone = pynini.union(
pynutil.insert("currency: \"R$\" integer_part: \"0\" ") + cents_standalone,
pynutil.add_weight(
pynutil.insert("integer_part: \"0\" ")
+ cents_standalone
+ delete_extra_space
+ pynutil.delete("de")
+ delete_space
+ graph_unit_singular,
-0.1,
),
)
graph_decimal = (
graph_decimal_final + delete_extra_space + (pynutil.delete("de") + delete_space).ques + graph_unit_plural
)
graph_decimal |= graph_cents_standalone
final_graph = graph_integer | graph_decimal
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/money.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.utils import get_abs_path
from nemo_text_processing.text_normalization.en.graph_utils import (
NEMO_ALPHA,
NEMO_DIGIT,
NEMO_SIGMA,
NEMO_SPACE,
NEMO_WHITE_SPACE,
GraphFst,
delete_space,
)
from pynini.lib import pynutil
class CardinalFst(GraphFst):
"""
Finite state transducer for classifying cardinals
e.g. menos veintitrés -> cardinal { negative: "-" integer: "23"}
This class converts cardinals up to (but not including) "un cuatrillón",
i.e up to "one septillion" in English (10^{24}).
Cardinals below ten are not converted (in order to avoid
"vivo em uma casa" --> "vivo em 1 casa" and any other odd conversions.)
Although technically Portuguese grammar requires that "e" only comes after
"10s" numbers (ie. "trinta", ..., "noventa"), these rules will convert
numbers even with "e" in an ungrammatical place (because "e" is ignored
inside cardinal numbers).
e.g. "mil e uma" -> cardinal { integer: "1001"}
e.g. "cento e uma" -> cardinal { integer: "101"}
"""
def __init__(self, use_strict_e=False):
"""
:param use_strict_e: When True forces to have the separator "e" in the right places
"""
super().__init__(name="cardinal", kind="classify")
graph_zero = pynini.string_file(get_abs_path("data/numbers/zero.tsv"))
graph_digit = pynini.string_file(get_abs_path("data/numbers/digit.tsv"))
graph_ties = pynini.string_file(get_abs_path("data/numbers/ties.tsv"))
graph_teen = pynini.string_file(get_abs_path("data/numbers/teen.tsv"))
graph_twenties = pynini.string_file(get_abs_path("data/numbers/twenties.tsv"))
graph_one_hundred = pynini.string_file(get_abs_path("data/numbers/onehundred.tsv"))
graph_hundreds = pynini.string_file(get_abs_path("data/numbers/hundreds.tsv"))
graph = None
if not use_strict_e:
graph_hundred_component = graph_hundreds | pynutil.insert("0")
graph_hundred_component += delete_space
graph_hundred_component += pynini.union(
graph_twenties | graph_teen | pynutil.insert("00"),
(graph_ties | pynutil.insert("0")) + delete_space + (graph_digit | pynutil.insert("0")),
)
graph_hundred_component = pynini.union(graph_hundred_component, graph_one_hundred)
graph_hundred_component_at_least_one_none_zero_digit = graph_hundred_component @ (
pynini.closure(NEMO_DIGIT) + (NEMO_DIGIT - "0") + pynini.closure(NEMO_DIGIT)
)
graph_thousands = pynini.union(
graph_hundred_component_at_least_one_none_zero_digit + delete_space + pynutil.delete("mil"),
pynutil.insert("001") + pynutil.delete("mil"), # because we say 'mil', not 'hum mil'
pynutil.insert("000", weight=0.01),
)
graph_milhoes = pynini.union(
graph_hundred_component_at_least_one_none_zero_digit
+ delete_space
+ (pynutil.delete("milhão") | pynutil.delete("milhões")),
pynutil.insert("000", weight=0.01),
)
graph_bilhoes = pynini.union(
graph_hundred_component_at_least_one_none_zero_digit
+ delete_space
+ (pynutil.delete("bilhão") | pynutil.delete("bilhões")),
pynutil.insert("000", weight=0.01),
)
graph_trilhoes = pynini.union(
graph_hundred_component_at_least_one_none_zero_digit
+ delete_space
+ (pynutil.delete("trilhão") | pynutil.delete("trilhões")),
pynutil.insert("000", weight=0.01),
)
graph_quatrilhoes = pynini.union(
graph_hundred_component_at_least_one_none_zero_digit
+ delete_space
+ (pynutil.delete("quatrilhão") | pynutil.delete("quatrilhões")),
pynutil.insert("000", weight=0.01),
)
graph_quintilhoes = pynini.union(
graph_hundred_component_at_least_one_none_zero_digit
+ delete_space
+ (pynutil.delete("quintilhão") | pynutil.delete("quintilhões")),
pynutil.insert("000", weight=0.01),
)
graph_sextilhoes = pynini.union(
graph_hundred_component_at_least_one_none_zero_digit
+ delete_space
+ (pynutil.delete("sextilhão") | pynutil.delete("sextilhões")),
pynutil.insert("000", weight=0.01),
)
graph = pynini.union(
graph_sextilhoes
+ delete_space
+ graph_quintilhoes
+ delete_space
+ graph_quatrilhoes
+ delete_space
+ graph_trilhoes
+ delete_space
+ graph_bilhoes
+ delete_space
+ graph_milhoes
+ delete_space
+ graph_thousands
+ delete_space
+ graph_hundred_component,
graph_zero,
)
graph = graph @ pynini.union(
pynutil.delete(pynini.closure("0")) + pynini.difference(NEMO_DIGIT, "0") + pynini.closure(NEMO_DIGIT),
"0",
)
graph = (
pynini.cdrewrite(pynutil.delete("e"), NEMO_SPACE, NEMO_SPACE, NEMO_SIGMA)
@ (NEMO_ALPHA + NEMO_SIGMA)
@ graph
)
else:
graph_e = (
pynutil.delete(NEMO_WHITE_SPACE.plus) + pynutil.delete("e") + pynutil.delete(NEMO_WHITE_SPACE.plus)
)
graph_ties_component = pynini.union(
graph_teen | graph_twenties,
graph_ties + ((graph_e + graph_digit) | pynutil.insert("0")),
pynutil.add_weight(pynutil.insert("0") + graph_digit, 0.1),
) @ (pynini.closure(NEMO_DIGIT) + (NEMO_DIGIT - "0") + pynini.closure(NEMO_DIGIT))
graph_hundreds_except_hundred = (pynini.project(graph_hundreds, "input") - "cento") @ graph_hundreds
graph_hundred_component_prefix_e = pynini.union(
graph_one_hundred,
pynutil.add_weight(graph_hundreds_except_hundred + pynutil.insert("00"), 0.1),
pynutil.insert("0") + graph_ties_component,
) @ (pynini.closure(NEMO_DIGIT) + (NEMO_DIGIT - "0") + pynini.closure(NEMO_DIGIT))
graph_hundred_component_prefix_e = graph_hundred_component_prefix_e.optimize()
graph_hundred_component_no_prefix = pynini.union(graph_hundreds + graph_e + graph_ties_component,) @ (
pynini.closure(NEMO_DIGIT) + (NEMO_DIGIT - "0") + pynini.closure(NEMO_DIGIT)
)
graph_hundred_component_no_prefix = graph_hundred_component_no_prefix.optimize()
graph_mil_prefix_e = pynini.union(
# because we say 'mil', not 'hum mil'
(
(graph_hundred_component_prefix_e + delete_space + pynutil.delete("mil"))
| (pynutil.insert("001", weight=0.1) + pynutil.delete("mil"))
)
+ (
(graph_e + graph_hundred_component_prefix_e)
| (delete_space + graph_hundred_component_no_prefix)
| pynutil.insert("000", weight=0.1)
)
)
graph_mil_no_prefix = pynini.union(
(
(graph_hundred_component_no_prefix + delete_space + pynutil.delete("mil"))
| pynutil.insert("000", weight=0.1)
)
+ (
(graph_e + graph_hundred_component_prefix_e)
| (delete_space + graph_hundred_component_no_prefix)
| pynutil.insert("000", weight=0.1)
)
)
graph_milhao_prefix_e = pynini.union(
(
graph_hundred_component_prefix_e
+ delete_space
+ (pynutil.delete("milhão") | pynutil.delete("milhões"))
)
+ ((graph_e + graph_mil_prefix_e) | (delete_space + graph_mil_no_prefix))
)
graph_milhao_no_prefix = pynini.union(
(
(
graph_hundred_component_no_prefix
+ delete_space
+ (pynutil.delete("milhão") | pynutil.delete("milhões"))
)
| pynutil.insert("000", weight=0.1)
)
+ ((graph_e + graph_mil_prefix_e) | (delete_space + graph_mil_no_prefix))
)
graph_bilhao_prefix_e = pynini.union(
(
graph_hundred_component_prefix_e
+ delete_space
+ (pynutil.delete("bilhão") | pynutil.delete("bilhões"))
)
+ ((graph_e + graph_milhao_prefix_e) | (delete_space + graph_milhao_no_prefix))
)
graph_bilhao_no_prefix = pynini.union(
(
(
graph_hundred_component_no_prefix
+ delete_space
+ (pynutil.delete("bilhão") | pynutil.delete("bilhões"))
)
| pynutil.insert("000", weight=0.1)
)
+ ((graph_e + graph_milhao_prefix_e) | (delete_space + graph_milhao_no_prefix))
)
graph_trilhao_prefix_e = pynini.union(
(
graph_hundred_component_prefix_e
+ delete_space
+ (pynutil.delete("trilhão") | pynutil.delete("trilhões"))
)
+ ((graph_e + graph_bilhao_prefix_e) | (delete_space + graph_bilhao_no_prefix))
)
graph_trilhao_no_prefix = pynini.union(
(
(
graph_hundred_component_no_prefix
+ delete_space
+ (pynutil.delete("trilhão") | pynutil.delete("trilhões"))
)
| pynutil.insert("000", weight=0.1)
)
+ ((graph_e + graph_bilhao_prefix_e) | (delete_space + graph_bilhao_no_prefix))
)
graph_quatrilhao_prefix_e = pynini.union(
(
graph_hundred_component_prefix_e
+ delete_space
+ (pynutil.delete("quatrilhão") | pynutil.delete("quatrilhões"))
)
+ ((graph_e + graph_trilhao_prefix_e) | (delete_space + graph_trilhao_no_prefix))
)
graph_quatrilhao_no_prefix = pynini.union(
(
(
graph_hundred_component_no_prefix
+ delete_space
+ (pynutil.delete("quatrilhão") | pynutil.delete("quatrilhões"))
)
| pynutil.insert("000", weight=0.1)
)
+ ((graph_e + graph_trilhao_prefix_e) | (delete_space + graph_trilhao_no_prefix))
)
graph_quintilhao_prefix_e = pynini.union(
(
graph_hundred_component_prefix_e
+ delete_space
+ (pynutil.delete("quintilhão") | pynutil.delete("quintilhões"))
)
+ ((graph_e + graph_quatrilhao_prefix_e) | (delete_space + graph_quatrilhao_no_prefix))
)
graph_quintilhao_no_prefix = pynini.union(
(
(
graph_hundred_component_no_prefix
+ delete_space
+ (pynutil.delete("quintilhão") | pynutil.delete("quintilhões"))
)
| pynutil.insert("000", weight=0.1)
)
+ ((graph_e + graph_quatrilhao_prefix_e) | (delete_space + graph_quatrilhao_no_prefix))
)
graph_sextilhao_prefix_e = pynini.union(
(
graph_hundred_component_prefix_e
+ delete_space
+ (pynutil.delete("sextilhão") | pynutil.delete("sextilhões"))
)
+ ((graph_e + graph_quintilhao_prefix_e) | (delete_space + graph_quintilhao_no_prefix))
)
graph_sextilhao_no_prefix = pynini.union(
(
(
graph_hundred_component_no_prefix
+ delete_space
+ (pynutil.delete("sextilhão") | pynutil.delete("sextilhões"))
)
| pynutil.insert("000", weight=0.1)
)
+ ((graph_e + graph_quintilhao_prefix_e) | (delete_space + graph_quintilhao_no_prefix))
)
graph = pynini.union(
graph_sextilhao_no_prefix,
graph_sextilhao_prefix_e,
graph_quintilhao_prefix_e,
graph_quatrilhao_prefix_e,
graph_trilhao_prefix_e,
graph_bilhao_prefix_e,
graph_milhao_prefix_e,
graph_mil_prefix_e,
graph_hundred_component_prefix_e,
graph_ties_component,
graph_zero,
).optimize()
graph = graph @ pynini.union(
pynutil.delete(pynini.closure("0")) + pynini.difference(NEMO_DIGIT, "0") + pynini.closure(NEMO_DIGIT),
"0",
)
graph = graph.optimize()
self.graph_no_exception = graph
# save self.numbers_up_to_thousand for use in DecimalFst
digits_up_to_thousand = NEMO_DIGIT | (NEMO_DIGIT ** 2) | (NEMO_DIGIT ** 3)
numbers_up_to_thousand = pynini.compose(graph, digits_up_to_thousand).optimize()
self.numbers_up_to_thousand = numbers_up_to_thousand
# save self.numbers_up_to_million for use in DecimalFst
digits_up_to_million = (
NEMO_DIGIT
| (NEMO_DIGIT ** 2)
| (NEMO_DIGIT ** 3)
| (NEMO_DIGIT ** 4)
| (NEMO_DIGIT ** 5)
| (NEMO_DIGIT ** 6)
)
numbers_up_to_million = pynini.compose(graph, digits_up_to_million).optimize()
self.numbers_up_to_million = numbers_up_to_million
# save self.digits_from_year for use in DateFst
digits_1_2099 = [str(digits) for digits in range(1, 2100)]
digits_from_year = (numbers_up_to_million @ pynini.union(*digits_1_2099)).optimize()
self.digits_from_year = digits_from_year
# don't convert cardinals from zero to nine inclusive
graph_exception = pynini.project(pynini.union(graph_digit, graph_zero), 'input')
self.graph = (pynini.project(graph, "input") - graph_exception.arcsort()) @ graph
optional_minus_graph = pynini.closure(
pynutil.insert("negative: ") + pynini.cross("menos", "\"-\"") + NEMO_SPACE, 0, 1
)
final_graph = optional_minus_graph + pynutil.insert("integer: \"") + self.graph + pynutil.insert("\"")
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/cardinal.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.utils import get_abs_path
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_ALPHA, GraphFst, insert_space
from pynini.lib import pynutil
class ElectronicFst(GraphFst):
"""
Finite state transducer for classifying 'electronic' semiotic classes, i.e.
email address (which get converted to "username" and "domain" fields),
and URLS (which get converted to a "protocol" field).
e.g. c d f um arroba a b c ponto e d u -> tokens { electronic { username: "cdf1" domain: "abc.edu" } }
e.g. dáblio dáblio dáblio a b c ponto e d u -> tokens { electronic { protocol: "www.abc.edu" } }
"""
def __init__(self):
super().__init__(name="electronic", kind="classify")
delete_extra_space = pynutil.delete(" ")
alpha_num = (
NEMO_ALPHA
| pynini.string_file(get_abs_path("data/numbers/digit.tsv"))
| pynini.string_file(get_abs_path("data/numbers/zero.tsv"))
)
symbols = pynini.string_file(get_abs_path("data/electronic/symbols.tsv")).invert()
accepted_username = alpha_num | symbols
process_dot = pynini.cross("ponto", ".")
username = (
pynutil.insert("username: \"")
+ alpha_num
+ delete_extra_space
+ pynini.closure(accepted_username + delete_extra_space)
+ alpha_num
+ pynutil.insert("\"")
)
single_alphanum = pynini.closure(alpha_num + delete_extra_space) + alpha_num
server = single_alphanum | pynini.string_file(get_abs_path("data/electronic/server_name.tsv")).invert()
domain = single_alphanum | pynini.string_file(get_abs_path("data/electronic/domain.tsv")).invert()
domain_graph = (
pynutil.insert("domain: \"")
+ server
+ delete_extra_space
+ process_dot
+ delete_extra_space
+ domain
+ pynutil.insert("\"")
)
graph = (
username + delete_extra_space + pynutil.delete("arroba") + insert_space + delete_extra_space + domain_graph
)
############# url ###
protocol_end = pynini.cross(pynini.union("www", "w w w", "dáblio dáblio dáblio"), "www")
protocol_start = pynini.cross(pynini.union("http", "h t t p", "agá tê tê pê"), "http")
protocol_start |= pynini.cross(pynini.union("https", "h t t p s", "agá tê tê pê ésse"), "https")
protocol_start += pynini.cross(" dois pontos barra barra ", "://")
# e.g. .com, .es
ending = (
delete_extra_space
+ symbols
+ delete_extra_space
+ (domain | pynini.closure(accepted_username + delete_extra_space) + accepted_username)
)
protocol = (
pynini.closure(protocol_start, 0, 1)
+ protocol_end
+ delete_extra_space
+ process_dot
+ delete_extra_space
+ (pynini.closure(delete_extra_space + accepted_username, 1) | server)
+ pynini.closure(ending, 1)
)
protocol = pynutil.insert("protocol: \"") + protocol + pynutil.insert("\"")
graph |= protocol
########
final_graph = self.add_tokens(graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/electronic.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.utils import get_abs_path
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst, delete_extra_space, delete_space
from pynini.lib import pynutil
class DateFst(GraphFst):
"""
Finite state transducer for classifying date,
e.g. primeiro de janeiro -> date { day: "1" month: "janeiro" }
e.g. um de janeiro -> date { day: "1" month: "janeiro" }
"""
def __init__(self, cardinal: GraphFst):
super().__init__(name="date", kind="classify")
digits_from_year = cardinal.digits_from_year
graph_digit = pynini.string_file(get_abs_path("data/numbers/digit.tsv"))
graph_ties = pynini.string_file(get_abs_path("data/numbers/ties.tsv"))
graph_teen = pynini.string_file(get_abs_path("data/numbers/teen.tsv"))
graph_twenties = pynini.string_file(get_abs_path("data/numbers/twenties.tsv"))
graph_1_to_100 = pynini.union(
pynutil.insert("0") + graph_digit,
graph_twenties,
graph_teen,
(graph_ties + pynutil.insert("0")),
(graph_ties + pynutil.delete(" e ") + graph_digit),
)
digits_1_to_31 = [str("{:0>2d}").format(digits) for digits in range(1, 32)]
graph_1_to_31 = graph_1_to_100 @ pynini.union(*digits_1_to_31)
# can use "primeiro" for 1st day of the month
graph_1_to_31 = pynini.union(graph_1_to_31, pynini.cross("primeiro", "01"))
day_graph = pynutil.insert("day: \"") + graph_1_to_31 + pynutil.insert("\"")
month_name_graph = pynini.string_file(get_abs_path("data/months.tsv"))
month_name_graph = pynutil.insert("month: \"") + month_name_graph + pynutil.insert("\"")
# vinte do oito -> 20/08
digits_1_to_12 = [str("{:0>2d}").format(digits) for digits in range(1, 13)]
graph_1_to_12 = graph_1_to_100 @ pynini.union(*digits_1_to_12)
month_number_graph = pynutil.insert("month: \"") + graph_1_to_12 + pynutil.insert("\"")
graph_dm = day_graph + delete_space + pynutil.delete("de") + delete_extra_space + month_name_graph
graph_dm |= (
day_graph
+ delete_space
+ pynutil.delete("do")
+ delete_extra_space
+ month_number_graph
+ pynutil.insert(" morphosyntactic_features: \"/\"")
)
graph_year = (
delete_space
+ pynutil.delete("de")
+ delete_extra_space
+ pynutil.insert("year: \"")
+ digits_from_year
+ pynutil.insert("\"")
)
graph_dmy = graph_dm + graph_year.ques
final_graph = graph_dmy
final_graph += pynutil.insert(" preserve_order: true")
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/date.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_SPACE, GraphFst
from pynini.lib import pynutil
class WordFst(GraphFst):
"""
Finite state transducer for classifying plain tokens, that do not belong to any special class. This can be considered as the default class.
e.g. sleep -> tokens { name: "sleep" }
"""
def __init__(self):
super().__init__(name="word", kind="classify")
word = pynutil.insert("name: \"") + pynini.closure(NEMO_NOT_SPACE, 1) + pynutil.insert("\"")
self.fst = word.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/taggers/word.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import (
NEMO_DIGIT,
NEMO_NOT_QUOTE,
GraphFst,
delete_space,
insert_space,
)
from pynini.lib import pynutil
class TimeFst(GraphFst):
"""
Finite state transducer for verbalizing time,
e.g. time { hours: "à 1" minutes: "10" } -> à 1:10
e.g. time { hours: "às 2" minutes: "45" } -> às 2:45
"""
def __init__(self):
super().__init__(name="time", kind="verbalize")
add_leading_zero_to_double_digit = (NEMO_DIGIT + NEMO_DIGIT) | (pynutil.insert("0") + NEMO_DIGIT)
prefix = (
pynutil.delete("morphosyntactic_features:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
+ delete_space
+ insert_space
)
optional_prefix = pynini.closure(prefix, 0, 1)
hour = (
pynutil.delete("hours:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_DIGIT, 1)
+ pynutil.delete("\"")
)
minute = (
pynutil.delete("minutes:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_DIGIT, 1)
+ pynutil.delete("\"")
)
suffix = (
delete_space
+ insert_space
+ pynutil.delete("suffix:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
optional_suffix = pynini.closure(suffix, 0, 1)
graph = (
optional_prefix
+ hour
+ delete_space
+ pynutil.insert(":")
+ (minute @ add_leading_zero_to_double_digit)
+ optional_suffix
)
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/time.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_CHAR, GraphFst, delete_space
from pynini.lib import pynutil
class MeasureFst(GraphFst):
"""
Finite state transducer for verbalizing measure, e.g.
measure { cardinal { negative: "true" integer: "12" } units: "kg" } -> -12 kg
Args:
decimal: DecimalFst
cardinal: CardinalFst
"""
def __init__(self, decimal: GraphFst, cardinal: GraphFst):
super().__init__(name="measure", kind="verbalize")
optional_sign = pynini.closure(pynini.cross("negative: \"true\"", "-"), 0, 1)
unit = (
pynutil.delete("units:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_CHAR - " ", 1)
+ pynutil.delete("\"")
+ delete_space
)
graph_decimal = (
pynutil.delete("decimal {")
+ delete_space
+ optional_sign
+ delete_space
+ decimal.numbers
+ delete_space
+ pynutil.delete("}")
)
graph_cardinal = (
pynutil.delete("cardinal {")
+ delete_space
+ optional_sign
+ delete_space
+ cardinal.numbers
+ delete_space
+ pynutil.delete("}")
)
graph = (graph_cardinal | graph_decimal) + delete_space + pynutil.insert(" ") + unit
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/measure.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst
from pynini.lib import pynutil
class TelephoneFst(GraphFst):
"""
Finite state transducer for verbalizing telephone, e.g.
telephone { number_part: "123-123-5678" }
-> 123-123-5678
"""
def __init__(self):
super().__init__(name="telephone", kind="verbalize")
number_part = pynutil.delete("number_part: \"") + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete("\"")
delete_tokens = self.delete_tokens(number_part)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/telephone.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst, delete_space
from pynini.lib import pynutil
class OrdinalFst(GraphFst):
"""
Finite state transducer for verbalizing ordinal, e.g.
ordinal { integer: "13" morphosyntactic_features: "o" } -> 13º
"""
def __init__(self):
super().__init__(name="ordinal", kind="verbalize")
graph = (
pynutil.delete("integer:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
replace_suffix = pynini.union(
pynini.cross(" morphosyntactic_features: \"o\"", "º"),
pynini.cross(" morphosyntactic_features: \"a\"", "ª"),
)
graph = graph + replace_suffix
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/ordinal.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.cardinal import CardinalFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.date import DateFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.decimal import DecimalFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.electronic import ElectronicFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.measure import MeasureFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.money import MoneyFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.ordinal import OrdinalFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.telephone import TelephoneFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.time import TimeFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.whitelist import WhiteListFst
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst
class VerbalizeFst(GraphFst):
"""
Composes other verbalizer grammars.
For deployment, this grammar will be compiled and exported to OpenFst Finite State Archive (FAR) File.
More details to deployment at NeMo/tools/text_processing_deployment.
"""
def __init__(self):
super().__init__(name="verbalize", kind="verbalize")
cardinal = CardinalFst()
cardinal_graph = cardinal.fst
ordinal_graph = OrdinalFst().fst
decimal = DecimalFst()
decimal_graph = decimal.fst
measure_graph = MeasureFst(decimal=decimal, cardinal=cardinal).fst
money_graph = MoneyFst(decimal=decimal).fst
time_graph = TimeFst().fst
date_graph = DateFst().fst
whitelist_graph = WhiteListFst().fst
telephone_graph = TelephoneFst().fst
electronic_graph = ElectronicFst().fst
graph = (
time_graph
| date_graph
| money_graph
| measure_graph
| ordinal_graph
| decimal_graph
| cardinal_graph
| whitelist_graph
| telephone_graph
| electronic_graph
)
self.fst = graph
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/verbalize.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_CHAR, NEMO_SIGMA, GraphFst, delete_space
from pynini.lib import pynutil
class WhiteListFst(GraphFst):
"""
Finite state transducer for verbalizing whitelist
e.g. tokens { name: "sexta feira" } -> "sexta-feira"
"""
def __init__(self):
super().__init__(name="whitelist", kind="verbalize")
graph = (
pynutil.delete("name:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_CHAR - " ", 1)
+ pynutil.delete("\"")
)
graph = graph @ pynini.cdrewrite(pynini.cross(u"\u00A0", " "), "", "", NEMO_SIGMA)
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/whitelist.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.verbalize import VerbalizeFst
from nemo_text_processing.inverse_text_normalization.pt.verbalizers.word import WordFst
from nemo_text_processing.text_normalization.en.graph_utils import GraphFst, delete_extra_space, delete_space
from pynini.lib import pynutil
class VerbalizeFinalFst(GraphFst):
"""
Finite state transducer that verbalizes an entire sentence, e.g.
tokens { name: "its" } tokens { time { hours: "12" minutes: "30" } } tokens { name: "now" } -> its 12:30 now
"""
def __init__(self):
super().__init__(name="verbalize_final", kind="verbalize")
verbalize = VerbalizeFst().fst
word = WordFst().fst
types = verbalize | word
graph = (
pynutil.delete("tokens")
+ delete_space
+ pynutil.delete("{")
+ delete_space
+ types
+ delete_space
+ pynutil.delete("}")
)
graph = delete_space + pynini.closure(graph + delete_extra_space) + graph + delete_space
self.fst = graph
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/verbalize_final.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/__init__.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst, delete_space
from pynini.lib import pynutil
class DecimalFst(GraphFst):
"""
Finite state transducer for verbalizing decimal,
e.g. decimal { negative: "true" integer_part: "1" morphosyntactic_features: "," fractional_part: "26" } -> -1,26
e.g. decimal { negative: "true" integer_part: "1" morphosyntactic_features: "." fractional_part: "26" } -> -1.26
e.g. decimal { negative: "false" integer_part: "1" morphosyntactic_features: "," fractional_part: "26" quantity: "millón" } -> 1,26 millón
e.g. decimal { negative: "false" integer_part: "2" quantity: "millones" } -> 2 millones
"""
def __init__(self):
super().__init__(name="decimal", kind="verbalize")
optionl_sign = pynini.closure(pynini.cross("negative: \"true\"", "-") + delete_space, 0, 1)
integer = (
pynutil.delete("integer_part:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
optional_integer = pynini.closure(integer + delete_space, 0, 1)
decimal_point = pynini.cross("morphosyntactic_features: \",\"", ",")
decimal_point |= pynini.cross("morphosyntactic_features: \".\"", ".")
fractional = (
decimal_point
+ delete_space
+ pynutil.delete("fractional_part:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
optional_fractional = pynini.closure(fractional + delete_space, 0, 1)
quantity = (
pynutil.delete("quantity:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
optional_quantity = pynini.closure(pynutil.insert(" ") + quantity + delete_space, 0, 1)
graph = optional_integer + optional_fractional + optional_quantity
self.numbers = graph
graph = optionl_sign + graph
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/decimal.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_CHAR, GraphFst, delete_space, insert_space
from pynini.lib import pynutil
class MoneyFst(GraphFst):
"""
Finite state transducer for verbalizing money, e.g.
money { integer_part: "12" morphosyntactic_features: "," fractional_part: "05" currency: "$" } -> $12,05
Args:
decimal: DecimalFst
"""
def __init__(self, decimal: GraphFst):
super().__init__(name="money", kind="verbalize")
unit = (
pynutil.delete("currency:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_CHAR - " ", 1)
+ pynutil.delete("\"")
)
graph = unit + delete_space + insert_space + decimal.numbers
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/money.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst, delete_space
from pynini.lib import pynutil
class CardinalFst(GraphFst):
"""
Finite state transducer for verbalizing cardinal
e.g. cardinal { negative: "-" integer: "23" } -> -23
"""
def __init__(self):
super().__init__(name="cardinal", kind="verbalize")
optional_sign = pynini.closure(
pynutil.delete("negative:")
+ delete_space
+ pynutil.delete("\"")
+ NEMO_NOT_QUOTE
+ pynutil.delete("\"")
+ delete_space,
0,
1,
)
graph = (
pynutil.delete("integer:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
self.numbers = graph
graph = optional_sign + graph
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/cardinal.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_NOT_QUOTE, GraphFst, delete_space
from pynini.lib import pynutil
class ElectronicFst(GraphFst):
"""
Finite state transducer for verbalizing electronic
e.g. tokens { electronic { username: "cdf1" domain: "abc.edu" } } -> [email protected]
e.g. tokens { electronic { protocol: "www.abc.edu" } } -> www.abc.edu
"""
def __init__(self):
super().__init__(name="electronic", kind="verbalize")
user_name = (
pynutil.delete("username:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
domain = (
pynutil.delete("domain:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
protocol = (
pynutil.delete("protocol:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
graph = user_name + delete_space + pynutil.insert("@") + domain
graph |= protocol
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/electronic.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import (
NEMO_NOT_QUOTE,
GraphFst,
delete_extra_space,
delete_space,
insert_space,
)
from pynini.lib import pynutil
class DateFst(GraphFst):
"""
Finite state transducer for verbalizing date, e.g.
date { day: "1" month: "enero" preserve_order: true } -> 1 de enero
"""
def __init__(self):
super().__init__(name="date", kind="verbalize")
month = (
pynutil.delete("month:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
day = (
pynutil.delete("day:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
year = (
pynutil.delete("year:")
+ delete_space
+ pynutil.delete("\"")
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete("\"")
)
# day month
graph_dmy = (
day
+ delete_extra_space
+ pynutil.insert("de")
+ insert_space
+ month
+ (delete_extra_space + pynutil.insert("de") + insert_space + year).ques
)
graph_dmy |= (
day
+ delete_space
+ pynutil.insert("/")
+ month
+ pynutil.delete(" morphosyntactic_features: \"/\"")
+ (delete_space + pynutil.insert("/") + year).ques
)
optional_preserve_order = pynini.closure(
pynutil.delete("preserve_order:") + delete_space + pynutil.delete("true") + delete_space
| pynutil.delete("field_order:")
+ delete_space
+ pynutil.delete("\"")
+ NEMO_NOT_QUOTE
+ pynutil.delete("\"")
+ delete_space
)
final_graph = graph_dmy + delete_space + optional_preserve_order
delete_tokens = self.delete_tokens(final_graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/date.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.en.graph_utils import NEMO_CHAR, NEMO_SIGMA, GraphFst, delete_space
from pynini.lib import pynutil
class WordFst(GraphFst):
"""
Finite state transducer for verbalizing plain tokens
e.g. tokens { name: "sleep" } -> sleep
"""
def __init__(self):
super().__init__(name="word", kind="verbalize")
chars = pynini.closure(NEMO_CHAR - " ", 1)
char = pynutil.delete("name:") + delete_space + pynutil.delete("\"") + chars + pynutil.delete("\"")
graph = char @ pynini.cdrewrite(pynini.cross(u"\u00A0", " "), "", "", NEMO_SIGMA)
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/verbalizers/word.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/data/__init__.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/data/numbers/__init__.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/data/ordinals/__init__.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/data/electronic/__init__.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/pt/data/time/__init__.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# Copyright 2015 and onwards Google, 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.
import os
import string
from pathlib import Path
from typing import Dict
import pynini
from pynini.export import export
from pynini.lib import byte, pynutil, utf8
NEMO_CHAR = utf8.VALID_UTF8_CHAR
NEMO_DIGIT = byte.DIGIT
NEMO_HEX = pynini.union(*string.hexdigits).optimize()
NEMO_NON_BREAKING_SPACE = "\u00A0"
NEMO_SPACE = " "
NEMO_WHITE_SPACE = pynini.union(" ", "\t", "\n", "\r", "\u00A0").optimize()
NEMO_NOT_SPACE = pynini.difference(NEMO_CHAR, NEMO_WHITE_SPACE).optimize()
NEMO_NOT_QUOTE = pynini.difference(NEMO_CHAR, r'"').optimize()
NEMO_PUNCT = pynini.union(*map(pynini.escape, string.punctuation)).optimize()
NEMO_SIGMA = pynini.closure(NEMO_CHAR)
delete_space = pynutil.delete(pynini.closure(NEMO_WHITE_SPACE))
delete_zero_or_one_space = pynutil.delete(pynini.closure(NEMO_WHITE_SPACE, 0, 1))
insert_space = pynutil.insert(" ")
delete_extra_space = pynini.cross(pynini.closure(NEMO_WHITE_SPACE, 1), " ")
delete_preserve_order = pynini.closure(
pynutil.delete(" preserve_order: true")
| (pynutil.delete(' field_order: "') + NEMO_NOT_QUOTE + pynutil.delete('"'))
)
INPUT_CASED = "cased"
INPUT_LOWER_CASED = "lower_cased"
def generator_main(file_name: str, graphs: Dict[str, 'pynini.FstLike']):
"""
Exports graph as OpenFst finite state archive (FAR) file with given file name and rule name.
Args:
file_name: exported file name
graphs: Mapping of a rule name and Pynini WFST graph to be exported
"""
exporter = export.Exporter(file_name)
for rule, graph in graphs.items():
exporter[rule] = graph.optimize()
exporter.close()
print(f"Created {file_name}")
def convert_space(fst) -> "pynini.FstLike":
"""
Converts space to nonbreaking space.
Used only in tagger grammars for transducing token values within quotes, e.g. name: "hello kitty"
This is making transducer significantly slower, so only use when there could be potential spaces within quotes, otherwise leave it.
Args:
fst: input fst
Returns output fst where breaking spaces are converted to non breaking spaces
"""
return fst @ pynini.cdrewrite(pynini.cross(NEMO_SPACE, NEMO_NON_BREAKING_SPACE), "", "", NEMO_SIGMA)
def string_map_cased(input_file: str, input_case: str = INPUT_LOWER_CASED):
labels = load_labels(input_file)
if input_case == INPUT_CASED:
additional_labels = []
for written, spoken, *weight in labels:
written_capitalized = written[0].upper() + written[1:]
additional_labels.extend(
[
[written_capitalized, spoken.capitalize(),], # first letter capitalized
[
written_capitalized,
spoken.upper().replace(" AND ", " and "),
], # # add pairs with the all letters capitalized
]
)
spoken_no_space = spoken.replace(" ", "")
# add abbreviations without spaces (both lower and upper case), i.e. "BMW" not "B M W"
if len(spoken) == (2 * len(spoken_no_space) - 1):
print(f"This is weight {weight}")
if len(weight) == 0:
additional_labels.extend(
[[written, spoken_no_space], [written_capitalized, spoken_no_space.upper()],]
)
else:
additional_labels.extend(
[
[written, spoken_no_space, weight[0]],
[written_capitalized, spoken_no_space.upper(), weight[0]],
]
)
labels += additional_labels
whitelist = pynini.string_map(labels).invert().optimize()
return whitelist
class GraphFst:
"""
Base class for all grammar fsts.
Args:
name: name of grammar class
kind: either 'classify' or 'verbalize'
deterministic: if True will provide a single transduction option,
for False multiple transduction are generated (used for audio-based normalization)
"""
def __init__(self, name: str, kind: str, deterministic: bool = True):
self.name = name
self.kind = str
self._fst = None
self.deterministic = deterministic
self.far_path = Path(os.path.dirname(__file__) + "/grammars/" + kind + "/" + name + ".far")
if self.far_exist():
self._fst = pynini.Far(self.far_path, mode="r", arc_type="standard", far_type="default").get_fst()
def far_exist(self) -> bool:
"""
Returns true if FAR can be loaded
"""
return self.far_path.exists()
@property
def fst(self) -> "pynini.FstLike":
return self._fst
@fst.setter
def fst(self, fst):
self._fst = fst
def add_tokens(self, fst) -> "pynini.FstLike":
"""
Wraps class name around to given fst
Args:
fst: input fst
Returns:
Fst: fst
"""
return pynutil.insert(f"{self.name} {{ ") + fst + pynutil.insert(" }")
def delete_tokens(self, fst) -> "pynini.FstLike":
"""
Deletes class name wrap around output of given fst
Args:
fst: input fst
Returns:
Fst: fst
"""
res = (
pynutil.delete(f"{self.name}")
+ delete_space
+ pynutil.delete("{")
+ delete_space
+ fst
+ delete_space
+ pynutil.delete("}")
)
return res @ pynini.cdrewrite(pynini.cross("\u00A0", " "), "", "", NEMO_SIGMA)
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/graph_utils.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
from nemo_text_processing.inverse_text_normalization.zh.taggers.tokenize_and_classify import ClassifyFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.verbalize import VerbalizeFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.verbalize_final import VerbalizeFinalFst
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/__init__.py |
# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
#
# 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.
import os
from typing import List, Union
import inflect
_inflect = inflect.engine()
def num_to_word(x: Union[str, int]):
"""
converts integer to spoken representation
Args
x: integer
Returns: spoken representation
"""
if isinstance(x, int):
x = str(x)
x = _inflect.number_to_words(str(x)).replace("-", " ").replace(",", "")
return x
def get_abs_path(rel_path):
"""
Get absolute path
Args:
rel_path: relative path to this file
Returns absolute path
"""
return os.path.dirname(os.path.abspath(__file__)) + "/" + rel_path
def get_various_formats(text: str) -> List[str]:
"""
Return various formats for text, e.g., all caps, the first letter upper cased, space separated, etc.
"""
result = []
if len(text) == 0:
return []
for t in [text, " ".join(list(text))]:
result.append(t)
result.append(t.upper())
result.append(t.capitalize())
return result
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/utils.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import GraphFst
from nemo_text_processing.inverse_text_normalization.zh.utils import get_abs_path
from pynini.lib import pynutil
class TimeFst(GraphFst):
"""
Finite state transducer for classifying time
e.g., 五点十分 -> time { hours: "05" minutes: "10" }
e.g., 五时十五分 -> time { hours: "05" minutes: "15" }
e.g., 十五点十分 -> time { hours: "15" minutes: "10" }
e.g., 十五点十分二十秒 -> time { hours: "15" minutes: "10" seconds: "20 }
e.g., 两点一刻 -> time { hours: "2" minutes: "1刻" }
e.g., 五点 -> time { hours: "5点" }
e.g., 五小时 -> time { hours: "5小时" }
e.g., 五分 -> time { minutess: "5分" }
e.g., 五分钟 -> time { seconds: "5分钟" }
e.g., 五秒 -> time { seconds: "5秒" }
e.g., 五秒钟 -> time { seconds: "5秒钟" }
"""
def __init__(self):
super().__init__(name="time", kind="classify")
hours = pynini.string_file(get_abs_path("data/time/time_hours.tsv"))
minutes = pynini.string_file(get_abs_path("data/time/time_minutes.tsv"))
seconds = pynini.string_file(get_abs_path("data/time/time_seconds.tsv"))
quarters = pynini.string_file(get_abs_path("data/time/time_quarters.tsv"))
for_mandarin = pynini.string_file(get_abs_path("data/time/time_mandarin.tsv"))
graph_delete_hours = pynutil.delete("点") | pynutil.delete("點") | pynutil.delete("时") | pynutil.delete("時")
graph_hours = hours + graph_delete_hours
graph_hours_component = pynutil.insert('hours: "') + graph_hours + pynutil.insert('"')
graph_minutes = pynutil.delete("分")
graph_minutes = minutes + graph_minutes
graph_minutes_component = pynutil.insert('minutes: "') + graph_minutes + pynutil.insert('"')
graph_seconds = pynutil.delete("秒")
graph_seconds = seconds + graph_seconds
graph_seconds_component = pynutil.insert('seconds: "') + graph_seconds + pynutil.insert('"')
graph_time_standard = (graph_hours_component + pynutil.insert(" ") + graph_minutes_component) | (
graph_hours_component
+ pynutil.insert(" ")
+ graph_minutes_component
+ pynutil.insert(" ")
+ graph_seconds_component
)
quarter_mandarin = (
quarters + pynini.accep("刻") | pynini.cross("刻鈡", "刻钟") | pynini.accep("刻钟") | pynini.accep("半")
)
hour_mandarin = (
pynini.accep("点")
| pynini.accep("时")
| pynini.cross("點", "点")
| pynini.cross("時", "时")
| pynini.accep("小时")
| pynini.cross("小時", "小时")
| pynini.cross("個點", "个点")
| pynini.accep("个点")
| pynini.accep("个钟头")
| pynini.cross("個鐘頭", "个钟头")
| pynini.accep("个小时")
| pynini.cross("個小時", "个小时")
)
minute_mandarin = pynini.accep("分") | pynini.cross("分鐘", "分钟") | pynini.accep("分钟")
second_mandarin = pynini.accep("秒") | pynini.cross("秒鐘", "秒钟") | pynini.accep("秒钟")
hours_only = for_mandarin + hour_mandarin
minutes_only = for_mandarin + minute_mandarin
seconds_only = for_mandarin + second_mandarin
graph_mandarin_hour = pynutil.insert('hours: "') + hours_only + pynutil.insert('"')
graph_mandarin_minute = pynutil.insert('minutes: "') + minutes_only + pynutil.insert('"')
graph_mandarin_second = pynutil.insert('seconds: "') + seconds_only + pynutil.insert('"')
graph_mandarin_quarter = pynutil.insert('minutes: "') + quarter_mandarin + pynutil.insert('"')
graph_mandarins = (
graph_mandarin_hour
| graph_mandarin_minute
| graph_mandarin_second
| graph_mandarin_quarter
| (graph_mandarin_hour + pynutil.insert(" ") + graph_mandarin_quarter)
)
final_graph = graph_time_standard | graph_mandarins
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/time.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import GraphFst
from pynini.lib import pynutil
class FractionFst(GraphFst):
"""
Finite state transducer for classifying fraction
e.g. 二分之一 -> tokens { fraction { denominator: "2" numerator: "1"} }
e.g. 五又二分之一 -> tokens { fraction { integer_part: "1" denominator: "2" numerator: "1" } }
Args:
cardinal: CardinalFst
"""
def __init__(self, cardinal: GraphFst):
super().__init__(name="fraction", kind="classify")
graph_cardinal = cardinal.just_cardinals
integer_component = pynutil.insert('integer_part: "') + graph_cardinal + pynutil.insert('"')
denominator_component = (
pynutil.insert('denominator: "') + graph_cardinal + pynutil.delete("分之") + pynutil.insert('"')
)
numerator_component = pynutil.insert('numerator: "') + graph_cardinal + pynutil.insert('"')
graph_only_fraction = denominator_component + pynutil.insert(" ") + numerator_component
graph_fraction_with_int = integer_component + pynutil.delete("又") + pynutil.insert(" ") + graph_only_fraction
graph_fraction = graph_only_fraction | graph_fraction_with_int
final_graph = self.add_tokens(graph_fraction)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/fraction.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import GraphFst
from pynini.lib import pynutil
class OrdinalFst(GraphFst):
def __init__(self, cardinal: GraphFst):
super().__init__(name="ordinal", kind="classify")
graph_cardinals = cardinal.for_ordinals
mandarin_morpheme = pynini.accep("第")
graph_ordinal = mandarin_morpheme + graph_cardinals
graph_ordinal_final = pynutil.insert('integer: "') + graph_ordinal + pynutil.insert('"')
graph_ordinal_final = self.add_tokens(graph_ordinal_final)
self.fst = graph_ordinal_final.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/ordinal.py |
# Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
# Copyright 2015 and onwards Google, 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import INPUT_LOWER_CASED, GraphFst
from nemo_text_processing.inverse_text_normalization.zh.utils import get_abs_path
from pynini.lib import pynutil
class WhiteListFst(GraphFst):
"""
Finite state transducer for classifying whitelisted tokens
e.g. 贵宾 -> tokens { name: "VIP" }
美国研究生入学考试 -> { name: "GRE" }
人力资源 -> { name: "HR" }
工商管理学硕士 -> { name: "MBA" }
This class has highest priority among all classifier grammars. Whitelisted tokens are defined and loaded from "data/whitelist.tsv".
"""
def __init__(self, input_case: str = INPUT_LOWER_CASED, input_file: str = None):
super().__init__(name="whitelist", kind="classify")
whitelist = pynini.string_file(get_abs_path("data/whitelist.tsv"))
graph = (pynutil.insert('name: "')) + (whitelist) + pynutil.insert('"')
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/whitelist.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import logging
import os
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import (
GraphFst,
delete_extra_space,
delete_space,
generator_main,
)
from nemo_text_processing.inverse_text_normalization.zh.taggers.cardinal import CardinalFst
from nemo_text_processing.inverse_text_normalization.zh.taggers.date import DateFst
from nemo_text_processing.inverse_text_normalization.zh.taggers.decimal import DecimalFst
from nemo_text_processing.inverse_text_normalization.zh.taggers.fraction import FractionFst
from nemo_text_processing.inverse_text_normalization.zh.taggers.money import MoneyFst
from nemo_text_processing.inverse_text_normalization.zh.taggers.ordinal import OrdinalFst
from nemo_text_processing.inverse_text_normalization.zh.taggers.punctuation import PunctuationFst
from nemo_text_processing.inverse_text_normalization.zh.taggers.time import TimeFst
from nemo_text_processing.inverse_text_normalization.zh.taggers.whitelist import WhiteListFst
from nemo_text_processing.inverse_text_normalization.zh.taggers.word import WordFst
from pynini.lib import pynutil
class ClassifyFst(GraphFst):
"""
Final class that composes all other classification grammars. This class can process an entire sentence, that is lower cased.
For deployment, this grammar will be compiled and exported to OpenFst Finate State Archiv (FAR) File.
More details to deployment at NeMo/tools/text_processing_deployment.
Args:
cache_dir: path to a dir with .far grammar file. Set to None to avoid using cache.
overwrite_cache: set to True to overwrite .far files
"""
def __init__(
self, input_case: str, cache_dir: str = None, whitelist: str = None, overwrite_cache: bool = False,
):
super().__init__(name="tokenize_and_classify", kind="classify")
far_file = None
if cache_dir is not None and cache_dir != "None":
os.makedirs(cache_dir, exist_ok=True)
far_file = os.path.join(cache_dir, "_zh_itn.far")
if not overwrite_cache and far_file and os.path.exists(far_file):
self.fst = pynini.Far(far_file, mode="r")["tokenize_and_classify"]
logging.info(f"ClassifyFst.fst was restored from {far_file}.")
else:
logging.info(f"Creating ClassifyFst grammars.")
cardinal = CardinalFst()
cardinal_graph = cardinal.fst
ordinal = OrdinalFst(cardinal)
ordinal_graph = ordinal.fst
decimal = DecimalFst(cardinal)
decimal_graph = decimal.fst
date_graph = DateFst().fst
word_graph = WordFst().fst
time_graph = TimeFst().fst
money_graph = MoneyFst(cardinal=cardinal, decimal=decimal).fst
fraction = FractionFst(cardinal)
fraction_graph = fraction.fst
punct_graph = PunctuationFst().fst
whitelist_graph = WhiteListFst(input_file=whitelist, input_case=input_case).fst
classify = (
pynutil.add_weight(time_graph, 1.1)
| pynutil.add_weight(date_graph, 1.09)
| pynutil.add_weight(decimal_graph, 1.2)
| pynutil.add_weight(cardinal_graph, 1.09)
| pynutil.add_weight(ordinal_graph, 1.1)
| pynutil.add_weight(money_graph, 1.1)
| pynutil.add_weight(fraction_graph, 1.1)
| pynutil.add_weight(word_graph, 100)
| pynutil.add_weight(whitelist_graph, 1.01)
)
punct = pynutil.insert("tokens { ") + pynutil.add_weight(punct_graph, weight=1.1) + pynutil.insert(" }")
token = pynutil.insert("tokens { ") + classify + pynutil.insert(" }")
token_plus_punct = (
pynini.closure(punct + pynutil.insert(" ")) + token + pynini.closure(pynutil.insert(" ") + punct)
)
graph = token_plus_punct + pynini.closure(delete_extra_space + token_plus_punct)
graph = delete_space + graph + delete_space
self.fst = graph.optimize()
if far_file:
generator_main(far_file, {"tokenize_and_classify": self.fst})
logging.info(f"ClassifyFst grammars are saved to {far_file}.")
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/tokenize_and_classify.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import GraphFst
from pynini.lib import pynutil
class PunctuationFst(GraphFst):
"""
Finite state transducer for classifying punctuation
e.g. a, -> tokens { name: "a" } tokens { name: "," }
"""
def __init__(self):
super().__init__(name="punctuation", kind="classify")
s = "!#$%&'()*+,-./:;<=>?@^_`{|}~。，；：《》“”·~【】！？、‘’.<>-——_"
punct = pynini.union(*s)
graph = pynutil.insert('name: "') + punct + pynutil.insert('"')
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/punctuation.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/__init__.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import GraphFst
from nemo_text_processing.inverse_text_normalization.zh.utils import get_abs_path
from pynini.lib import pynutil
def get_quantity(decimal, cardinal):
suffix = pynini.union(
"万",
"十万",
"百万",
"千万",
"亿",
"十亿",
"百亿",
"千亿",
"萬",
"十萬",
"百萬",
"千萬",
"億",
"十億",
"百億",
"千億",
"拾萬",
"佰萬",
"仟萬",
"拾億",
"佰億",
"仟億",
"拾万",
"佰万",
"仟万",
"仟亿",
"佰亿",
"仟亿",
)
numbers = cardinal
res = (
pynutil.insert('integer_part: "')
+ numbers
+ pynutil.insert('"')
+ pynutil.insert(' quantity: "')
+ suffix
+ pynutil.insert('"')
)
res = res | decimal + pynutil.insert(' quantity: "') + suffix + pynutil.insert('"')
return res
class DecimalFst(GraphFst):
def __init__(self, cardinal: GraphFst):
super().__init__(name="decimal", kind="classify")
cardinal_after_decimal = pynini.string_file(get_abs_path("data/numbers/digit-nano.tsv")) | pynini.closure(
pynini.cross("零", "0")
)
cardinal_before_decimal = cardinal.just_cardinals | pynini.cross("零", "0")
delete_decimal = pynutil.delete("点") | pynutil.delete("點")
graph_integer = pynutil.insert('integer_part: "') + cardinal_before_decimal + pynutil.insert('" ')
graph_string_of_cardinals = pynini.closure(cardinal_after_decimal, 1)
graph_fractional = pynutil.insert('fractional_part: "') + graph_string_of_cardinals + pynutil.insert('"')
graph_decimal_no_sign = pynini.closure((graph_integer + delete_decimal + graph_fractional), 1)
self.final_graph_wo_negative = graph_decimal_no_sign | get_quantity(
graph_decimal_no_sign, cardinal.just_cardinals
)
graph_negative = pynini.cross("负", 'negative: "-" ') | pynini.cross("負", 'negative: "-" ')
graph_negative = pynini.closure(graph_negative, 0, 1) # captures only one "负"
graph_decimal = graph_negative + graph_decimal_no_sign
graph_decimal = graph_decimal | (graph_negative + get_quantity(graph_decimal_no_sign, cardinal_before_decimal))
self.final_graph_wo_negative = graph_decimal
final_graph = self.add_tokens(graph_decimal)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/decimal.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import NEMO_DIGIT, GraphFst
from nemo_text_processing.inverse_text_normalization.zh.utils import get_abs_path
from pynini.lib import pynutil
class MoneyFst(GraphFst):
def __init__(self, cardinal: GraphFst, decimal: GraphFst):
super().__init__(name="money", kind="classify")
# imports
major_currency = pynini.string_file(get_abs_path("data/money/currency_major.tsv"))
minor_currency = pynini.string_file(get_abs_path("data/money/currency_minor.tsv"))
digits = pynini.string_file(get_abs_path("data/numbers/digit-nano.tsv"))
graph_cardinal = cardinal.for_ordinals
graph_decimal = decimal.final_graph_wo_negative #
# add leding zero to the number: 1 -> 01
add_leading_zero_to_double_digit = (NEMO_DIGIT + NEMO_DIGIT) | (pynutil.insert("0") + NEMO_DIGIT) #
graph_fractional_values = graph_cardinal @ add_leading_zero_to_double_digit #
# regular number and yuan part
graph_integer_component = pynutil.insert('integer_part: "') + graph_cardinal + pynutil.insert('"')
graph_fractional_component = (
pynutil.insert('fractional_part: "') + graph_fractional_values + pynutil.insert('"')
)
# regular symbol part
graph_major_currency = pynutil.insert('currency: "') + major_currency + pynutil.insert('"')
graph_minor_currency = pynutil.insert('currency: "') + minor_currency + pynutil.insert('"')
# regular combine number and symbol part
graph_only_major = graph_integer_component + pynutil.insert(" ") + graph_major_currency
graph_only_minor = graph_fractional_component + pynutil.insert(" ") + graph_minor_currency
graph_money = graph_only_major + pynutil.insert(" ") + graph_fractional_component
# regular large money with decimals
graph_large_money = graph_decimal + pynutil.insert(" ") + graph_major_currency
# final graph for regular currency
graph_regular_money = graph_only_major | graph_only_minor | graph_money | graph_large_money
# yuan major plus minor
major_symbol = pynini.accep("块") | pynini.cross("塊", "块")
tencent = pynini.accep("毛") | pynini.accep("角",)
cent = pynini.accep("分")
graph_kuai = (
graph_integer_component
+ pynutil.insert(" ")
+ pynutil.insert('currency_major: "')
+ pynini.closure(major_symbol, 1, 1)
+ pynutil.insert('"')
)
graph_mao = (
graph_integer_component
+ pynutil.insert(" ")
+ pynutil.insert('currency_minor: "')
+ pynini.closure(tencent, 1, 1)
+ pynutil.insert('"')
)
graph_fen = (
graph_integer_component
+ pynutil.insert(" ")
+ pynutil.insert('currency_minor: "')
+ pynini.closure(cent, 1, 1)
+ pynutil.insert('"')
)
graph_digits = pynutil.insert('fractional_part: "') + digits + pynutil.insert('"')
graph_kuaimao = (
graph_kuai
+ pynutil.insert(" ")
+ graph_digits
+ pynutil.insert(" ")
+ pynutil.insert('currency_minor: "')
+ pynini.closure(tencent, 1, 1)
+ pynutil.insert('"')
)
graph_kuaifen = (
graph_kuai
+ pynutil.insert(" ")
+ graph_digits
+ pynutil.insert(" ")
+ pynutil.insert('currency_minor: "')
+ pynini.closure(cent, 1, 1)
+ pynutil.insert('"')
)
graph_maofen = (
pynutil.insert('fractional_part: "')
+ digits
+ pynutil.insert('"')
+ pynutil.insert(" ")
+ pynutil.insert('currency_minor: "')
+ pynini.closure(tencent, 1, 1)
+ pynutil.insert('"')
+ pynutil.insert(" ")
+ pynutil.insert('fraction_part: "')
+ digits
+ pynutil.insert('"')
+ pynutil.insert(" ")
+ pynutil.insert('currency_min: "')
+ pynini.closure(cent, 1, 1)
+ pynutil.insert('"')
)
graph_kuaimaofen = (
graph_kuai
+ pynutil.insert(" ")
+ pynutil.insert('fractional_part: "')
+ digits
+ pynutil.insert('"')
+ pynutil.insert(" ")
+ pynutil.insert('currency_minor: "')
+ pynini.closure(tencent, 1, 1)
+ pynutil.insert('"')
+ pynutil.insert(" ")
+ pynutil.insert('fraction_part: "')
+ digits
+ pynutil.insert('"')
+ pynutil.insert(" ")
+ pynutil.insert('currency_min: "')
+ pynini.closure(cent, 1, 1)
+ pynutil.insert('"')
)
graph_mandarin = (
graph_kuai | graph_mao | graph_fen | graph_kuaimao | graph_kuaifen | graph_maofen | graph_kuaimaofen
)
# combing both
graph_final = graph_regular_money | graph_mandarin
final = self.add_tokens(graph_final)
self.fst = final.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/money.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import NEMO_DIGIT, NEMO_SIGMA, GraphFst
from nemo_text_processing.inverse_text_normalization.zh.utils import get_abs_path
from pynini.lib import pynutil
class CardinalFst(GraphFst):
def __init__(self):
"""
Fitite state transducer for classifying cardinals (e.g., 负五十 -> cardinal { negative: "-" integer: "50" })
This class converts cardinals up to hundred millions (i.e., (10**10))
Single unit digits are not converted (e.g., 五 -> 五)
Numbers less than 20 are not converted.
二十 (2 characters/logograms) is kept as it is but 二十一 (3 characters/logograms) would become 21
"""
super().__init__(name="cardinal", kind="classify")
# number of digits to be processed
delete_hundreds = pynutil.delete("百") | pynutil.delete("佰")
delete_thousands = pynutil.delete("千") | pynutil.delete("仟")
closure_ten_thousands = pynini.accep("萬") | pynini.accep("万")
delete_ten_thousands = pynutil.delete("萬") | pynutil.delete("万")
closure_hundred_millions = pynini.accep("亿") | pynini.accep("億")
delete_hundred_millions = pynutil.delete("亿") | pynutil.delete("億")
# data imported
zero = pynini.string_file(get_abs_path("data/numbers/zero.tsv"))
digits = pynini.string_file(get_abs_path("data/numbers/digit-nano.tsv"))
ties = pynini.string_file(get_abs_path("data/numbers/ties-nano.tsv"))
# grammar for digits
graph_digits = digits | pynutil.insert("0")
# grammar for teens
ten = pynini.string_map([("十", "1"), ("拾", "1"), ("壹拾", "1"), ("一十", "1")])
graph_teens = ten + graph_digits
# grammar for tens, not the output for Cardinal grammar but for pure Arabic digits (used in other grammars)
graph_tens = (ties + graph_digits) | (pynini.cross(pynini.accep("零"), "0") + graph_digits)
graph_all = graph_tens | graph_teens | pynutil.insert("00")
# grammar for hundreds 百
graph_hundreds_complex = (
(graph_digits + delete_hundreds + graph_all)
| (graph_digits + delete_hundreds + pynini.cross(pynini.closure("零"), "0") + graph_digits)
| (graph_digits + delete_hundreds + graph_teens)
)
graph_hundreds = graph_hundreds_complex
graph_hundreds = graph_hundreds | pynutil.insert("000")
# grammar for thousands 千
graph_thousands_complex = (
(graph_digits + delete_thousands + graph_hundreds_complex)
| (graph_digits + delete_thousands + pynini.cross(pynini.closure("零"), "0") + graph_all)
| (graph_digits + delete_thousands + pynini.cross(pynini.closure("零"), "00") + graph_digits)
)
graph_thousands = graph_thousands_complex | pynutil.insert("000")
# grammar for ten thousands 万
graph_ten_thousands_simple = graph_digits + closure_ten_thousands
graph_ten_thousands_complex = (
(graph_digits + delete_ten_thousands + graph_thousands_complex)
| (graph_digits + delete_ten_thousands + pynini.cross(pynini.closure("零"), "0") + graph_hundreds_complex)
| (graph_digits + delete_ten_thousands + pynini.cross(pynini.closure("零"), "00") + graph_all)
| (graph_digits + delete_ten_thousands + pynini.cross(pynini.closure("零"), "000") + graph_digits)
)
graph_ten_thousands = (
pynutil.add_weight(graph_ten_thousands_simple, -1.0)
| graph_ten_thousands_complex
| pynutil.insert("00000")
)
# grammmar for hundred thousands 十万
graph_hundred_thousands_simple = graph_all + closure_ten_thousands
graph_hundred_thousands_complex = (
(graph_all + delete_ten_thousands + graph_thousands_complex)
| (graph_all + delete_ten_thousands + pynini.cross(pynini.closure("零"), "0") + graph_hundreds_complex)
| (graph_all + delete_ten_thousands + pynini.cross(pynini.closure("零"), "00") + graph_all)
| (graph_all + delete_ten_thousands + pynini.cross(pynini.closure("零"), "000") + graph_digits)
)
graph_hundred_thousands = (
pynutil.add_weight(graph_hundred_thousands_simple, -1.0)
| graph_hundred_thousands_complex
| pynutil.insert("000000")
)
# grammar for millions 百万
graph_millions_simple = graph_hundreds_complex + closure_ten_thousands
graph_millions_complex = (
(graph_hundreds_complex + delete_ten_thousands + graph_thousands_complex)
| (
graph_hundreds_complex
+ delete_ten_thousands
+ pynini.cross(pynini.closure("零"), "0")
+ graph_hundreds_complex
)
| (graph_hundreds_complex + delete_ten_thousands + pynini.cross(pynini.closure("零"), "00") + graph_all)
| (graph_hundreds_complex + delete_ten_thousands + pynini.cross(pynini.closure("零"), "000") + graph_digits)
)
graph_millions = (
pynutil.add_weight(graph_millions_simple, -1.0) | graph_millions_complex | pynutil.insert("0000000")
)
# grammar for ten millions 千万
graph_ten_millions_simple = graph_thousands_complex + closure_ten_thousands
graph_ten_millions_complex = (
(graph_thousands_complex + delete_ten_thousands + graph_thousands_complex)
| (
graph_thousands_complex
+ delete_ten_thousands
+ pynini.cross(pynini.closure("零"), "0")
+ graph_hundreds_complex
)
| (graph_thousands_complex + delete_ten_thousands + pynini.cross(pynini.closure("零"), "00") + graph_all)
| (
graph_thousands_complex
+ delete_ten_thousands
+ pynini.cross(pynini.closure("零"), "000")
+ graph_digits
)
)
graph_ten_millions = pynutil.add_weight(graph_ten_millions_simple, -1.0) | graph_ten_millions_complex
graph_ten_millions = graph_ten_millions | pynutil.insert("00000000")
# grammar for hundred millions 亿
graph_hundred_millions_simple = graph_digits + closure_hundred_millions
graph_hundred_millions_complex = (
(graph_digits + delete_hundred_millions + graph_ten_millions_complex)
| (
graph_digits
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "0")
+ graph_millions_complex
)
| (
graph_digits
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "00")
+ graph_hundred_thousands_complex
)
| (
graph_digits
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "000")
+ graph_ten_thousands_complex
)
| (
graph_digits
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "0000")
+ graph_thousands_complex
)
| (
graph_digits
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "00000")
+ graph_hundreds_complex
)
| (graph_digits + delete_hundred_millions + pynini.cross(pynini.closure("零"), "000000") + graph_all)
| (graph_digits + delete_hundred_millions + pynini.cross(pynini.closure("零"), "0000000") + graph_digits)
)
graph_hundred_millions = (
pynutil.add_weight(graph_hundred_millions_simple, -1.0)
| graph_hundred_millions_complex
| pynutil.insert("000000000")
)
# grammar for billions 十亿
graph_billions_simple = graph_all + closure_hundred_millions
graph_billions_complex = (
(graph_all + delete_hundred_millions + graph_ten_millions_complex)
| (graph_all + delete_hundred_millions + pynini.cross(pynini.closure("零"), "0") + graph_millions_complex)
| (
graph_all
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "00")
+ graph_hundred_thousands_complex
)
| (
graph_all
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "000")
+ graph_ten_thousands_complex
)
| (
graph_all
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "0000")
+ graph_thousands_complex
)
| (
graph_all
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "00000")
+ graph_hundreds_complex
)
| (graph_all + delete_hundred_millions + pynini.cross(pynini.closure("零"), "000000") + graph_all)
| (graph_all + delete_hundred_millions + pynini.cross(pynini.closure("零"), "0000000") + graph_digits)
)
graph_billions = (
pynutil.add_weight(graph_billions_simple, -1.0) | graph_billions_complex | pynutil.insert("0000000000")
)
# grammar for ten billions 百亿
graph_ten_billions_simple = graph_hundreds_complex + closure_hundred_millions
graph_ten_billions_complex = (
(graph_hundreds_complex + delete_hundred_millions + graph_ten_millions_complex)
| (
graph_hundreds_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "0")
+ graph_millions_complex
)
| (
graph_hundreds_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "00")
+ graph_hundred_thousands_complex
)
| (
graph_hundreds_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "000")
+ graph_ten_thousands_complex
)
| (
graph_hundreds_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "0000")
+ graph_thousands_complex
)
| (
graph_hundreds_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "00000")
+ graph_hundreds_complex
)
| (
graph_hundreds_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "000000")
+ graph_all
)
| (
graph_hundreds_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "0000000")
+ graph_digits
)
)
graph_ten_billions = (
pynutil.add_weight(graph_ten_billions_simple, -1.0)
| graph_ten_billions_complex
| pynutil.insert("00000000000")
)
# grammar for hundred billions 千亿
graph_hundred_billions_simple = graph_thousands_complex + closure_hundred_millions
graph_hundred_billions_complex = (
(graph_thousands_complex + delete_hundred_millions + graph_ten_millions_complex)
| (
graph_thousands_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "0")
+ graph_millions_complex
)
| (
graph_thousands_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "00")
+ graph_hundred_thousands_complex
)
| (
graph_thousands_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "000")
+ graph_ten_thousands_complex
)
| (
graph_thousands_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "0000")
+ graph_thousands_complex
)
| (
graph_thousands_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "00000")
+ graph_hundreds_complex
)
| (
graph_thousands_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "000000")
+ graph_all
)
| (
graph_thousands_complex
+ delete_hundred_millions
+ pynini.cross(pynini.closure("零"), "0000000")
+ graph_digits
)
)
graph_hundred_billions = (
pynutil.add_weight(graph_hundred_billions_simple, -1.0) | graph_hundred_billions_complex
)
# combining grammar; output for cardinal grammar
graph = pynini.union(
graph_hundred_billions,
graph_ten_billions,
graph_billions,
graph_hundred_millions,
graph_ten_millions,
graph_millions,
graph_hundred_thousands,
graph_ten_thousands,
graph_thousands,
graph_hundreds,
graph_all,
graph_teens,
graph_digits,
zero,
)
# combining grammar; output consists only arabic numbers
graph_just_cardinals = pynini.union(
graph_hundred_billions_complex,
graph_ten_billions_complex,
graph_billions_complex,
graph_hundred_millions_complex,
graph_ten_millions_complex,
graph_millions_complex,
graph_hundred_thousands_complex,
graph_ten_thousands_complex,
graph_thousands_complex,
graph_hundreds_complex,
graph_all,
graph_teens,
graph_digits,
zero,
)
# delete unnecessary leading zero
delete_leading_zeros = pynutil.delete(pynini.closure("0"))
stop_at_non_zero = pynini.difference(NEMO_DIGIT, "0")
rest_of_cardinal = pynini.closure(NEMO_DIGIT) | pynini.closure(NEMO_SIGMA)
# output for cardinal grammar without leading zero
clean_cardinal = delete_leading_zeros + stop_at_non_zero + rest_of_cardinal
clean_cardinal = clean_cardinal | "0"
graph = graph @ clean_cardinal # output for regular cardinals
self.for_ordinals = graph # used for ordinal grammars
# output for pure arabic number without leading zero
clean_just_cardinal = delete_leading_zeros + stop_at_non_zero + rest_of_cardinal
clean_just_cardinal = clean_just_cardinal | "0"
graph_just_cardinals = graph_just_cardinals @ clean_just_cardinal # output for other grammars
self.just_cardinals = graph_just_cardinals # used for other grammars
# final grammar for cardinal output; tokenization
optional_minus_graph = (pynini.closure(pynutil.insert("negative: ") + pynini.cross("负", '"-"'))) | (
pynini.closure(pynutil.insert("negative: ") + pynini.cross("負", '"-"'))
)
final_graph = optional_minus_graph + pynutil.insert('integer: "') + graph + pynutil.insert('"')
final_graph = self.add_tokens(final_graph)
self.fst = final_graph
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/cardinal.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import GraphFst
from nemo_text_processing.inverse_text_normalization.zh.utils import get_abs_path
from pynini.lib import pynutil
class DateFst(GraphFst):
def __init__(self):
"""
Finite state transducer for classifying date
1798年五月三十日 -> date { year: "1798" month: "5" day: "30" }
五月三十日 -> date { month: "5" day: "30" }
一六七二年 -> date { year: "1672" }
"""
super().__init__(name="date", kind="classify")
digits = pynini.string_file(get_abs_path("data/numbers/digit-nano.tsv")) # imported for year-component
months = pynini.string_file(get_abs_path("data/date/months.tsv")) # imported for month-component
days = pynini.string_file(get_abs_path("data/date/day.tsv")) # imported for day-component
# grammar for year
graph_year = (
pynini.closure(digits)
+ pynini.closure(pynini.cross("零", "0"))
+ pynini.closure(digits)
+ pynini.closure(pynini.cross("零", "0"))
+ pynutil.delete("年")
)
graph_year = pynutil.insert('year: "') + graph_year + pynutil.insert('"')
# grammar for month
graph_month = pynutil.insert('month: "') + months + pynutil.delete("月") + pynutil.insert('"')
# grammar for day
graph_day_suffix = pynini.accep("日") | pynini.accep("号") | pynini.accep("號")
graph_delete_day_suffix = pynutil.delete(graph_day_suffix)
graph_day = pynutil.insert('day: "') + days + graph_delete_day_suffix + pynutil.insert('"')
# grammar for combinations of year+month, month+day, and year+month+day
graph_ymd = graph_year + pynutil.insert(" ") + graph_month + pynutil.insert(" ") + graph_day
graph_ym = graph_year + pynutil.insert(" ") + graph_month
graph_md = graph_month + pynutil.insert(" ") + graph_day
# final grammar for standard date
graph_date = graph_ymd | graph_ym | graph_md | graph_year | graph_month | graph_day
# graph_date = graph_year | graph_month | graph_day
# grammar for optional prefix ad or bc
graph_bc_prefix = pynini.closure("紀元前", 0, 1) | pynini.closure("公元前", 0, 1) | pynini.closure("纪元前", 0, 1)
graph_bc = pynutil.delete(graph_bc_prefix)
graph_ad_prefix = (
pynini.closure("公元", 0, 1)
| pynini.closure("公元后", 0, 1) + pynini.closure("紀元", 0, 1)
| pynini.closure("纪元", 0, 1)
| pynini.closure("西元", 0, 1)
)
graph_ad = pynutil.delete(graph_ad_prefix)
graph_suffix_bc = (
graph_bc + graph_date + pynutil.insert(' era: "') + pynutil.insert("B.C.") + pynutil.insert('"')
)
graph_suffix_ad = (
graph_ad + graph_date + pynutil.insert(' era: "') + pynutil.insert("A.D.") + pynutil.insert('"')
)
graph_era = graph_suffix_bc | graph_suffix_ad
# grammar for standard date and with era
graph_date_final = graph_era | graph_date
# graph_date_final = graph_date
final_graph = self.add_tokens(graph_date_final)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/date.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import NEMO_NOT_SPACE, GraphFst
from pynini.lib import pynutil
class WordFst(GraphFst):
"""
Finite state transducer for classifying plain tokens, that do not belong to any special class. This can be considered as the default class.
e.g. sleep -> tokens { name: "sleep" }
"""
def __init__(self):
super().__init__(name="word", kind="classify")
word = pynutil.insert('name: "') + pynini.closure(NEMO_NOT_SPACE, 1) + pynutil.insert('"')
self.fst = word.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/taggers/word.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import NEMO_DIGIT, GraphFst, delete_space
from pynini.lib import pynutil
class TimeFst(GraphFst):
"""
Finite state transcucer for verbalizing time, e.g.,
time { hours: "12" minutes: "30" } -> 12:30
time { hours: "01" minutes: "30" } -> 01:30
time { hours: "1" minutes: "30" seconds: "05" } -> 01:30:05
time { hours: "1" minutes: "1刻" } -> 1点1刻
time { hours: "一点" } -> 1点
time { hours: "一小时" } -> 1小时
time { hours: "一个钟头" } -> 1个钟头
time { minutes: "一分" } -> 1分
time { minutes: "一分钟" } -> 1分钟
time { seconds: "一秒" } -> 1秒
time { seconds: "一秒钟" } -> 1秒钟
time { hours: "五点" minutes: "一刻" } -> 5点1刻
"""
def __init__(self):
super().__init__(name="time", kind="verbalize")
# add_leading_zero = (NEMO_DIGIT + NEMO_DIGIT) | (pynutil.insert("0") + NEMO_DIGIT)
token_hour = (
pynutil.delete("hours:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_DIGIT, 1, 2)
+ pynutil.delete('"')
)
token_minute = (
pynutil.delete("minutes:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_DIGIT, 1, 2)
+ pynutil.delete('"')
)
token_second = (
pynutil.delete("seconds:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_DIGIT, 1, 2)
+ pynutil.delete('"')
)
add_colon = pynutil.insert(":")
graph_regular_time = (token_hour + delete_space + add_colon + token_minute) | (
token_hour + delete_space + add_colon + token_minute + delete_space + add_colon + token_second
)
hours = (
pynini.accep("点")
| pynini.accep("小时")
| pynini.accep("时")
| pynini.accep("个钟头")
| pynini.accep("个点")
| pynini.accep("个小时")
)
hour_mandarin = (
pynutil.delete("hours:")
+ delete_space
+ pynutil.delete('"')
+ (pynini.closure(NEMO_DIGIT) + pynini.closure(hours, 1))
+ pynutil.delete('"')
)
minutes = pynini.accep("分") | pynini.accep("分钟") | pynini.accep("半")
minute_mandarin = (
pynutil.delete("minutes:")
+ delete_space
+ pynutil.delete('"')
+ (((pynini.closure(NEMO_DIGIT) + pynini.closure(minutes, 1))) | pynini.closure(minutes, 1))
+ pynutil.delete('"')
)
seconds = pynini.accep("秒") | pynini.accep("秒钟")
second_mandarin = (
pynutil.delete("seconds:")
+ delete_space
+ pynutil.delete('"')
+ (pynini.closure(NEMO_DIGIT) + pynini.closure(seconds, 1))
+ pynutil.delete('"')
)
quarters = pynini.accep("刻") | pynini.accep("刻钟")
quarter_mandarin = (
pynutil.delete("minutes:")
+ delete_space
+ pynutil.delete('"')
+ (pynini.closure(NEMO_DIGIT) + pynini.closure(quarters, 1))
+ pynutil.delete('"')
)
graph_mandarin_time = (
hour_mandarin
| minute_mandarin
| second_mandarin
| quarter_mandarin
| (hour_mandarin + delete_space + quarter_mandarin)
| (hour_mandarin + delete_space + minute_mandarin)
| (hour_mandarin + delete_space + minute_mandarin + delete_space + second_mandarin)
| (minute_mandarin + delete_space + second_mandarin)
)
final_graph = graph_regular_time | graph_mandarin_time
delete_tokens = self.delete_tokens(final_graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/time.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import NEMO_DIGIT, GraphFst, delete_space
from pynini.lib import pynutil
class FractionFst(GraphFst):
"""
Finite state transducer for verbalizing fraction
e.g. tokens { fraction { denominator: "2" numerator: "1"} } -> 1/2
e.g. tokens { fraction { integer_part: "1" denominator: "2" numerator: "1" } } -> 1又1/2
"""
def __init__(self):
super().__init__(name="fraction", kind="verbalize")
integer_part = (
pynutil.delete("integer_part:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_DIGIT)
+ pynutil.insert("又")
+ pynutil.delete('"')
)
denominator_part = (
pynutil.delete("denominator:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_DIGIT)
+ pynutil.delete('"')
)
numerator_part = (
pynutil.delete("numerator:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_DIGIT)
+ pynutil.insert("/")
+ pynutil.delete('"')
)
graph_with_integer = integer_part + delete_space + numerator_part + delete_space + denominator_part
graph_no_integer = numerator_part + delete_space + denominator_part
final_graph = graph_with_integer | graph_no_integer
delete_tokens = self.delete_tokens(final_graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/fraction.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import (
NEMO_DIGIT,
NEMO_SIGMA,
GraphFst,
delete_space,
)
from pynini.lib import pynutil
class OrdinalFst(GraphFst):
def __init__(self):
super().__init__(name="ordinal", kind="verbalize")
graph_integer = (
pynutil.delete("integer:")
+ delete_space
+ pynutil.delete('"')
+ pynini.accep("第")
+ pynini.closure(NEMO_DIGIT)
+ pynini.closure(NEMO_SIGMA)
+ pynutil.delete('"')
)
delete_tokens = self.delete_tokens(graph_integer)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/ordinal.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import GraphFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.cardinal import CardinalFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.date import DateFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.decimal import DecimalFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.fraction import FractionFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.money import MoneyFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.ordinal import OrdinalFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.time import TimeFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.whitelist import WhiteListFst
class VerbalizeFst(GraphFst):
"""
Composes other verbalizer grammars.
For deployment, this grammar will be compiled and exported to OpenFst Finate State Archiv (FAR) File.
More details to deployment at NeMo/tools/text_processing_deployment.
"""
def __init__(self):
super().__init__(name="verbalize", kind="verbalize")
cardinal = CardinalFst()
cardinal_graph = cardinal.fst
ordinal_graph = OrdinalFst().fst
decimal = DecimalFst()
decimal_graph = decimal.fst
fraction = FractionFst()
fraction_graph = fraction.fst
money = MoneyFst()
money_graph = money.fst
time_graph = TimeFst().fst
date_graph = DateFst().fst
whitelist_graph = WhiteListFst().fst
graph = (
time_graph
| date_graph
| money_graph
| fraction_graph
| ordinal_graph
| decimal_graph
| cardinal_graph
| whitelist_graph
)
self.fst = graph
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/verbalize.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import (
NEMO_CHAR,
NEMO_SIGMA,
GraphFst,
delete_space,
)
from pynini.lib import pynutil
class WhiteListFst(GraphFst):
"""
Finite state transducer for verbalizing whitelist
e.g. tokens { name: "USB" } -> USB
"""
def __init__(self):
super().__init__(name="whitelist", kind="verbalize")
graph = (
pynutil.delete("name:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_CHAR - " ", 1)
+ pynutil.delete('"')
)
graph = graph @ pynini.cdrewrite(pynini.cross(u"\u00A0", " "), "", "", NEMO_SIGMA)
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/whitelist.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import GraphFst, delete_extra_space, delete_space
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.verbalize import VerbalizeFst
from nemo_text_processing.inverse_text_normalization.zh.verbalizers.word import WordFst
from pynini.lib import pynutil
class VerbalizeFinalFst(GraphFst):
"""
Finite state transducer that verbalizes an entire sentence, e.g.
tokens { name: "its" } tokens { time { hours: "12" minutes: "30" } } tokens { name: "now" } -> its 12:30 now
"""
def __init__(self):
super().__init__(name="verbalize_final", kind="verbalize")
verbalize = VerbalizeFst().fst
word = WordFst().fst
types = verbalize | word
graph = (
pynutil.delete("tokens")
+ delete_space
+ pynutil.delete("{")
+ delete_space
+ types
+ delete_space
+ pynutil.delete("}")
)
graph = delete_space + pynini.closure(graph + delete_extra_space) + graph + delete_space
self.fst = graph
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/verbalize_final.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/__init__.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import (
NEMO_DIGIT,
NEMO_NOT_QUOTE,
GraphFst,
delete_space,
)
from pynini.lib import pynutil
class DecimalFst(GraphFst):
def __init__(self):
super().__init__(name="decimal", kind="verbalize")
# group numbers by three
exactly_three_digits = NEMO_DIGIT ** 3
at_most_three_digits = pynini.closure(NEMO_DIGIT, 1, 3)
# insert a "," for every three numbers before decimal point
space_every_three_integer = at_most_three_digits + (pynutil.insert(",") + exactly_three_digits).closure()
# removing tokenizations, 'negative: '
optional_sign = pynini.closure(
pynutil.delete("negative: ")
+ delete_space
+ pynutil.delete('"')
+ pynini.accep("-")
+ pynutil.delete('"')
+ delete_space
)
# removing tokenzations, 'integer_part:'
integer = (
pynutil.delete("integer_part:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_DIGIT, 1)
+ pynutil.delete('"')
)
integer = integer @ space_every_three_integer
optional_integer = pynini.closure(integer + delete_space, 0, 1)
# removing tokenizations, 'fractionl_part'
fractional = (
pynutil.insert(".")
+ pynutil.delete("fractional_part:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete('"')
)
optional_fractional = pynini.closure(fractional + delete_space, 0, 1)
# removing tokenization, 'quantity:'
quantity = (
pynutil.delete("quantity:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete('"')
)
optional_quantity = pynini.closure(delete_space + quantity)
# combining graphs removing tokenizations *3
graph = (optional_integer + optional_fractional + optional_quantity).optimize()
graph = optional_sign + graph # add optional sign for negative number
self.numebrs = graph
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/decimal.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import (
NEMO_DIGIT,
NEMO_NOT_QUOTE,
GraphFst,
delete_space,
)
from pynini.lib import pynutil
class MoneyFst(GraphFst):
def __init__(self):
super().__init__(name="money", kind="verbalize")
currency_unit = pynutil.delete('currency: "') + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete('"')
number_unit = pynutil.delete('integer_part: "') + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete('"')
fraction_unit = pynutil.delete('fractional_part: "') + pynini.closure(NEMO_NOT_QUOTE, 1) + pynutil.delete('"')
decimal_unit = (
pynutil.insert(".")
+ pynutil.delete('fractional_part: "')
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete('"')
+ delete_space
+ pynutil.delete('quantity: "')
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ pynutil.delete('"')
)
# regular money part
graph_money_regular = (
currency_unit + delete_space + number_unit + delete_space + pynutil.insert(".") + fraction_unit
)
graph_only_major_regular = currency_unit + delete_space + number_unit
graph_only_minor_regular = currency_unit + delete_space + pynutil.insert("0.") + fraction_unit
graph_large_money = currency_unit + delete_space + number_unit + delete_space + decimal_unit
graph_regular = graph_money_regular | graph_only_major_regular | graph_only_minor_regular | graph_large_money
major_symbol = pynini.accep("块")
minor_symbol = pynini.accep("毛") | pynini.accep("角")
lesser_symbol = pynini.accep("分")
major_currency = pynutil.delete('currency_major: "') + major_symbol + pynutil.delete('"')
minor_currency = pynutil.delete('currency_minor: "') + minor_symbol + pynutil.delete('"')
lesser_currency = pynutil.delete('currency_min:"') + lesser_symbol + pynutil.delete('"')
graph_kuai = number_unit + delete_space + major_currency
graph_mao = number_unit + delete_space + minor_currency
graph_fen = number_unit + delete_space + lesser_currency
graph_kuaimao = graph_kuai + delete_space + fraction_unit + delete_space + minor_currency
graph_kuaifen = graph_kuai + delete_space + fraction_unit + delete_space + lesser_currency
graph_maofen = (
pynutil.delete('fractional_part: "')
+ pynini.closure(NEMO_DIGIT, 1)
+ pynutil.delete('"')
+ delete_space
+ pynutil.delete('currency_minor: "')
+ minor_symbol
+ pynutil.delete('"')
+ delete_space
+ pynutil.delete('fraction_part: "')
+ pynini.closure(NEMO_DIGIT, 1)
+ pynutil.delete('"')
+ delete_space
+ pynutil.delete('currency_min: "')
+ lesser_symbol
+ pynutil.delete('"')
)
graph_all = graph_kuai + delete_space + graph_maofen
graph_mandarin = (
(graph_kuai | graph_mao | graph_fen) | graph_kuaimao | graph_kuaifen | graph_maofen | graph_all
)
graph_verbalizer = graph_regular | pynutil.add_weight(graph_mandarin, -2.0)
delete_tokens = self.delete_tokens(graph_verbalizer)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/money.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import (
NEMO_DIGIT,
NEMO_SIGMA,
GraphFst,
delete_space,
)
from pynini.lib import pynutil
class CardinalFst(GraphFst):
def __init__(self):
super().__init__(name="cardinal", kind="verbalize")
# group numbers by three
exactly_three_digits = NEMO_DIGIT ** 3
at_most_three_digits = pynini.closure(NEMO_DIGIT, 1, 3)
suffix = pynini.union(
"千",
"仟",
"万",
"十万",
"百万",
"千万",
"亿",
"十亿",
"百亿",
"千亿",
"萬",
"十萬",
"百萬",
"千萬",
"億",
"十億",
"百億",
"千億",
"拾萬",
"佰萬",
"仟萬",
"拾億",
"佰億",
"仟億",
"拾万",
"佰万",
"仟万",
"仟亿",
"佰亿",
"仟亿",
)
# inserting a "," between every 3 numbers
group_by_threes = (
at_most_three_digits + (pynutil.insert(",") + exactly_three_digits).closure()
) + pynini.closure(suffix)
# remove the negative attribute and leaves the sign if occurs
optional_sign = pynini.closure(
pynutil.delete("negative: ")
+ delete_space
+ pynutil.delete('"')
+ pynini.accep("-")
+ pynutil.delete('"')
+ delete_space
)
# remove integer aspect
graph = (
pynutil.delete("integer:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_DIGIT, 0, 1)
+ pynini.closure(NEMO_SIGMA)
+ pynutil.delete('"')
)
graph = graph @ group_by_threes
graph = optional_sign + graph
delete_tokens = self.delete_tokens(graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/cardinal.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import NEMO_NOT_QUOTE, GraphFst, delete_space
from pynini.lib import pynutil
class DateFst(GraphFst):
"""
Finite state transducer for verbalizing date, e.g.
date { year: "1798" month: "5" day: "30" } -> 1798年5月30日
date { year: "1798" month: "5" } -> 1798年5月
date { month: "5" day: "30" } -> 5月30日
"""
def __init__(self):
super().__init__(name="date", kind="verbalize")
# removing tokenization for year, month and day
year = (
pynutil.delete("year:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ delete_space
+ pynutil.delete('"')
)
month = (
pynutil.delete("month:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ delete_space
+ pynutil.delete('"')
)
day = (
pynutil.delete("day:")
+ delete_space
+ pynutil.delete('"')
+ pynini.closure(NEMO_NOT_QUOTE, 1)
+ delete_space
+ pynutil.delete('"')
)
era = pynutil.delete("era:")
bc = era + delete_space + pynutil.delete('"') + pynini.cross("A.D.", "公元") + pynutil.delete('"')
ad = era + delete_space + pynutil.delete('"') + pynini.cross("B.C.", "公元前") + pynutil.delete('"')
# combining above 3 for variations
graph_ymd = (
year
+ pynutil.insert("年")
+ delete_space
+ month
+ pynutil.insert("月")
+ delete_space
+ day
+ pynutil.insert("日")
)
graph_ym = year + pynutil.insert("年") + delete_space + month + pynutil.insert("月")
graph_md = month + pynutil.insert("月") + delete_space + day + pynutil.insert("日")
graph_year = year + pynutil.insert("年")
graph_month = month + pynutil.insert("月")
graph_day = day + pynutil.insert("日")
graph_era = bc | ad
optional_era = pynini.closure(graph_era)
final_graph = (
optional_era + delete_space + (graph_ymd | graph_ym | graph_md | graph_year | graph_month | graph_day)
)
delete_tokens = self.delete_tokens(final_graph)
self.fst = delete_tokens.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/date.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.inverse_text_normalization.zh.graph_utils import (
NEMO_CHAR,
NEMO_SIGMA,
GraphFst,
delete_space,
)
from pynini.lib import pynutil
class WordFst(GraphFst):
"""
Finite state transducer for verbalizing plain tokens
e.g. tokens { name: "sleep" } -> sleep
"""
def __init__(self):
super().__init__(name="word", kind="verbalize")
chars = pynini.closure(NEMO_CHAR - " ", 1)
char = pynutil.delete("name:") + delete_space + pynutil.delete('"') + chars + pynutil.delete('"')
graph = char @ pynini.cdrewrite(pynini.cross(u"\u00A0", " "), "", "", NEMO_SIGMA)
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/verbalizers/word.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/data/__init__.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/data/numbers/__init__.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/data/date/__init__.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/data/time/__init__.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/zh/data/money/__init__.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import logging
import pynini
from nemo_text_processing.inverse_text_normalization.en.taggers.tokenize_and_classify import ClassifyFst
from nemo_text_processing.inverse_text_normalization.en.verbalizers.verbalize import VerbalizeFst
from nemo_text_processing.inverse_text_normalization.en.verbalizers.verbalize_final import VerbalizeFinalFst
from pynini.lib import pynutil
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ar/__init__.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import os
from typing import Union
import inflect
_inflect = inflect.engine()
def num_to_word(x: Union[str, int]):
"""
converts integer to spoken representation
Args
x: integer
Returns: spoken representation
"""
if isinstance(x, int):
x = str(x)
x = _inflect.number_to_words(str(x)).replace("-", " ").replace(",", "")
return x
def get_abs_path(rel_path):
"""
Get absolute path
Args:
rel_path: relative path to this file
Returns absolute path
"""
return os.path.dirname(os.path.abspath(__file__)) + '/' + rel_path
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ar/utils.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.ar.graph_utils import GraphFst, convert_space, delete_extra_space
from nemo_text_processing.text_normalization.ar.taggers.measure import unit_singular
from pynini.lib import pynutil
class MeasureFst(GraphFst):
"""
Finite state transducer for classifying measure. Allows for plural form for unit.
e.g. "عشرون في المائة" -> measure { cardinal { integer: "20" } units: "%" }
Args:
itn_cardinal_tagger: ITN Cardinal tagger
itn_decimal_tagger: ITN Decimal tagger
itn_fraction_tagger: ITN Fraction tagger
"""
def __init__(
self,
itn_cardinal_tagger: GraphFst,
itn_decimal_tagger: GraphFst,
itn_fraction_tagger: GraphFst,
deterministic: bool = True,
):
super().__init__(name="measure", kind="classify", deterministic=deterministic)
cardinal_graph = itn_cardinal_tagger.graph
graph_unit_singular = pynini.invert(unit_singular)
unit = convert_space(graph_unit_singular)
optional_graph_negative = pynini.closure(
pynutil.insert("negative: ") + pynini.cross("سالب", "\"true\"") + delete_extra_space, 0, 1
)
unit = pynutil.insert("units: \"") + (unit) + pynutil.insert("\"")
subgraph_decimal = (
pynutil.insert("decimal { ")
+ optional_graph_negative
+ itn_decimal_tagger.final_graph_wo_negative
+ pynutil.insert(" }")
+ delete_extra_space
+ unit
)
subgraph_fraction = (
pynutil.insert("decimal { ")
+ optional_graph_negative
+ pynutil.insert("integer_part: \"")
+ itn_fraction_tagger.graph
+ pynutil.insert("\" }")
+ delete_extra_space
+ unit
)
subgraph_cardinal = (
pynutil.insert("cardinal { ")
+ optional_graph_negative
+ pynutil.insert("integer: \"")
+ cardinal_graph
+ pynutil.insert("\"")
+ pynutil.insert(" }")
+ delete_extra_space
+ unit
)
final_graph = subgraph_cardinal | subgraph_decimal | subgraph_fraction
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ar/taggers/measure.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.ar.graph_utils import (
NEMO_NOT_QUOTE,
GraphFst,
delete_space,
delete_zero_or_one_space,
insert_space,
)
from nemo_text_processing.text_normalization.ar.utils import get_abs_path
from pynini.lib import pynutil
class FractionFst(GraphFst):
"""
Finite state transducer for classifying fraction
e.g. واحد و نصف -> tokens { integer_part: "1" numerator: "1" denominator: "2" }
Args:
tn_cardinal: TN cardinal tagger
"""
def __init__(self, tn_cardinal: GraphFst):
super().__init__(name="fraction", kind="classify")
optional_graph_negative = pynini.closure(
pynutil.insert("negative: ") + pynini.cross("سالب", "\"true\" "), 0, 1
)
cardinal_graph = pynini.invert(tn_cardinal.cardinal_numbers).optimize()
# create unions for special cases
denominator_singular = pynini.union("نصف", "ثلث", "ربع", "خمس", "سدس", "سبع", "ثمن", "تسع", "عشر")
denominator_dual = pynini.union(
"نصفين", "ثلثين", "ربعين", "خمسين", "سدسين", "سبعين", "ثمنين", "تسعين", "عشرين"
)
denominator_plural = pynini.union("أخماس", "أرباع", "أثلاث", "أسداس", "أسباع", "أثمان", "أتساع", "أعشار")
numerator_three_to_ten = pynini.union("خمسة", "سبعة", "عشرة", "ثلاثة", "أربعة", "ستة", "ثمانية", "تسعة")
# data files
graph_ones = pynini.string_file(get_abs_path("data/number/fraction_singular.tsv")).invert().optimize()
graph_dual = pynini.string_file(get_abs_path("data/number/fraction_dual.tsv")).invert().optimize()
graph_plural = pynini.string_file(get_abs_path("data/number/fraction_plural.tsv")).invert().optimize()
# cases when denominator_singular
graph_denominator_singular = (
pynutil.insert("denominator: \"") + denominator_singular @ graph_ones + pynutil.insert("\"")
)
# cases when denominator_dual
graph_denominator_dual = (
pynutil.insert("denominator: \"") + denominator_dual @ graph_dual + pynutil.insert("\"")
)
# cases when denominator_plural
graph_denominator_plural = (
pynutil.insert("denominator: \"")
+ delete_zero_or_one_space
+ denominator_plural @ graph_plural
+ pynutil.insert("\"")
)
denominator_rest = pynutil.insert("denominator: \"") + cardinal_graph + pynutil.insert("\"")
numerator_rest = pynutil.insert("numerator: \"") + cardinal_graph + pynutil.insert("\" ")
# integer part
integer = pynutil.insert("integer_part: \"") + cardinal_graph + pynutil.insert("\"") + insert_space
# e.g نصف
numerator_one = pynutil.insert("numerator: \"1\"") + insert_space + graph_denominator_singular
# e.g. ثلثين
numerator_two = pynutil.insert("numerator: \"2\"") + insert_space + graph_denominator_dual
# e.g. ثلاثة أرباع
numerator_three_to_ten = (
pynutil.insert("numerator: \"")
+ numerator_three_to_ten @ cardinal_graph
+ pynutil.insert("\"")
+ insert_space
+ graph_denominator_plural
)
# e.g. اثنا عشر على أربعة وعشرون
numerators = (
numerator_rest
+ delete_zero_or_one_space
+ pynutil.delete("على")
+ delete_zero_or_one_space
+ denominator_rest
)
fraction = (
numerator_one | numerator_three_to_ten | numerator_two | pynutil.add_weight(numerators, 0.001)
) # apply exceptions first then the rest
conjunction = pynutil.delete("و")
integer = pynini.closure(integer + delete_zero_or_one_space + conjunction + delete_zero_or_one_space, 0, 1)
graph = optional_graph_negative + integer + fraction
self.graph = graph
final_graph = self.add_tokens(self.graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ar/taggers/fraction.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import logging
import os
import pynini
from nemo_text_processing.inverse_text_normalization.ar.taggers.cardinal import CardinalFst
from nemo_text_processing.inverse_text_normalization.ar.taggers.decimal import DecimalFst
from nemo_text_processing.inverse_text_normalization.ar.taggers.fraction import FractionFst
from nemo_text_processing.inverse_text_normalization.ar.taggers.measure import MeasureFst
from nemo_text_processing.inverse_text_normalization.ar.taggers.money import MoneyFst
from nemo_text_processing.inverse_text_normalization.ar.taggers.punctuation import PunctuationFst
from nemo_text_processing.inverse_text_normalization.ar.taggers.word import WordFst
from nemo_text_processing.text_normalization.ar.graph_utils import (
GraphFst,
delete_extra_space,
delete_space,
generator_main,
)
from nemo_text_processing.text_normalization.ar.taggers.tokenize_and_classify import ClassifyFst as TNClassifyFst
from nemo_text_processing.text_normalization.en.graph_utils import INPUT_LOWER_CASED
from pynini.lib import pynutil
class ClassifyFst(GraphFst):
"""
Final class that composes all other classification grammars. This class can process an entire sentence, that is lower cased.
For deployment, this grammar will be compiled and exported to OpenFst Finite State Archive (FAR) File.
More details to deployment at NeMo/tools/text_processing_deployment.
Args:
cache_dir: path to a dir with .far grammar file. Set to None to avoid using cache.
overwrite_cache: set to True to overwrite .far files
whitelist: path to a file with whitelist replacements
input_case: accepting either "lower_cased" or "cased" input.
"""
def __init__(
self,
cache_dir: str = None,
overwrite_cache: bool = False,
whitelist: str = None,
input_case: str = INPUT_LOWER_CASED,
):
super().__init__(name="tokenize_and_classify", kind="classify")
far_file = None
if cache_dir is not None and cache_dir != "None":
os.makedirs(cache_dir, exist_ok=True)
far_file = os.path.join(cache_dir, f"ar_itn_{input_case}.far")
if not overwrite_cache and far_file and os.path.exists(far_file):
self.fst = pynini.Far(far_file, mode="r")["tokenize_and_classify"]
logging.info(f"ClassifyFst.fst was restored from {far_file}.")
else:
logging.info(f"Creating ClassifyFst grammars.")
tn_classify = TNClassifyFst(
input_case='cased', deterministic=True, cache_dir=cache_dir, overwrite_cache=True
)
cardinal = CardinalFst(tn_cardinal=tn_classify.cardinal)
cardinal_graph = cardinal.fst
decimal = DecimalFst(tn_decimal=tn_classify.decimal)
decimal_graph = decimal.fst
fraction = FractionFst(tn_cardinal=tn_classify.cardinal)
fraction_graph = fraction.fst
money = MoneyFst(itn_cardinal_tagger=cardinal)
money_graph = money.fst
measure = MeasureFst(
itn_cardinal_tagger=cardinal,
itn_decimal_tagger=decimal,
itn_fraction_tagger=fraction,
deterministic=True,
)
measure_graph = measure.fst
word_graph = WordFst().fst
punct_graph = PunctuationFst().fst
classify = (
pynutil.add_weight(cardinal_graph, 1.1)
| pynutil.add_weight(decimal_graph, 1.1)
| pynutil.add_weight(fraction_graph, 1.1)
| pynutil.add_weight(money_graph, 1.1)
| pynutil.add_weight(measure_graph, 1.1)
| pynutil.add_weight(word_graph, 100)
)
punct = pynutil.insert("tokens { ") + pynutil.add_weight(punct_graph, weight=1.1) + pynutil.insert(" }")
token = pynutil.insert("tokens { ") + classify + pynutil.insert(" }")
token_plus_punct = (
pynini.closure(punct + pynutil.insert(" ")) + token + pynini.closure(pynutil.insert(" ") + punct)
)
graph = token_plus_punct + pynini.closure(delete_extra_space + token_plus_punct)
graph = delete_space + graph + delete_space
self.fst = graph.optimize()
if far_file:
generator_main(far_file, {"tokenize_and_classify": self.fst})
logging.info(f"ClassifyFst grammars are saved to {far_file}.")
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ar/taggers/tokenize_and_classify.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.ar.graph_utils import GraphFst
from pynini.lib import pynutil
class PunctuationFst(GraphFst):
"""
Finite state transducer for classifying punctuation
e.g. a, -> tokens { name: "a" } tokens { name: "," }
"""
def __init__(self):
super().__init__(name="punctuation", kind="classify")
s = "!#$%&\'()*+,-./:;<=>?@^_`{|}~"
punct = pynini.union(*s)
graph = pynutil.insert("name: \"") + punct + pynutil.insert("\"")
self.fst = graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ar/taggers/punctuation.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import logging
import pynini
from nemo_text_processing.inverse_text_normalization.en.taggers.tokenize_and_classify import ClassifyFst
from nemo_text_processing.inverse_text_normalization.en.verbalizers.verbalize import VerbalizeFst
from nemo_text_processing.inverse_text_normalization.en.verbalizers.verbalize_final import VerbalizeFinalFst
from pynini.lib import pynutil
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ar/taggers/__init__.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.ar.graph_utils import (
NEMO_SPACE,
GraphFst,
delete_extra_space,
insert_space,
)
from pynini.lib import pynutil
class DecimalFst(GraphFst):
"""
Finite state transducer for classifying decimal
e.g. "سبعة وتسعة وتسعون من مئة" -> decimal { negative: "false" integer_part: "7," fractional_part: "99" }
Args:
tn_decimal: Text normalization Decimal graph
"""
def __init__(self, tn_decimal):
super().__init__(name="decimal", kind="classify")
optional_graph_negative = pynini.closure(
pynutil.insert("negative: ") + pynini.cross("سالب", '"true"') + delete_extra_space, 0, 1,
)
graph_fractional_part = pynini.invert(tn_decimal.graph_fractional).optimize()
graph_integer_part = pynini.invert(tn_decimal.integer_part).optimize()
optional_graph_quantity = pynini.invert(tn_decimal.optional_quantity).optimize()
delete_seperator = pynini.string_map([("و", "")])
graph_fractional = (
pynutil.insert('fractional_part: "') + delete_seperator + graph_fractional_part + pynutil.insert('"')
)
graph_integer = pynutil.insert('integer_part: "') + graph_integer_part + pynutil.insert('"')
optional_graph_quantity = pynutil.insert('quantity: "') + optional_graph_quantity + pynutil.insert('"')
optional_graph_quantity = pynini.closure(pynini.accep(NEMO_SPACE) + optional_graph_quantity, 0, 1)
self.final_graph_wo_sign = (
graph_integer + pynini.accep(NEMO_SPACE) + graph_fractional + optional_graph_quantity
)
self.final_graph_wo_negative = optional_graph_negative + self.final_graph_wo_sign
final_graph = self.add_tokens(self.final_graph_wo_negative)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ar/taggers/decimal.py |
# Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.ar.graph_utils import (
NEMO_DIGIT,
NEMO_SIGMA,
GraphFst,
convert_space,
delete_extra_space,
delete_space,
insert_space,
)
from nemo_text_processing.text_normalization.ar.taggers.money import ar_cur, maj_singular, min_plural, min_singular
from pynini.lib import pynutil
class MoneyFst(GraphFst):
"""
Finite state transducer for classifying money
e.g. "خمسة ريال سعودي" -> money { integer_part: "5" currency: "ر.س" }
e.g. "سبعة دولار وتسعة وتسعون سنت" -> money { integer_part: "7" currency: "$" fractional_part: "99" }
Args:
itn_cardinal_tagger: ITN Cardinal Tagger
"""
def __init__(self, itn_cardinal_tagger: GraphFst, deterministic: bool = True):
super().__init__(name="money", kind="classify", deterministic=deterministic)
cardinal_graph = itn_cardinal_tagger.graph
graph_unit = pynini.invert(maj_singular)
graph_unit = pynutil.insert("currency: \"") + convert_space(graph_unit) + pynutil.insert("\"")
graph_ar_cur = pynini.invert(ar_cur)
graph_ar_cur = pynutil.insert("currency: \"") + convert_space(graph_ar_cur) + pynutil.insert("\"")
add_leading_zero_to_double_digit = (NEMO_DIGIT + NEMO_DIGIT) | (pynutil.insert("0") + NEMO_DIGIT)
min_unit = pynini.project(min_singular | min_plural, "output")
cents_standalone = (
pynutil.insert("fractional_part: \"")
+ cardinal_graph @ add_leading_zero_to_double_digit
+ delete_space
+ pynutil.delete(min_unit)
+ pynutil.insert("\"")
)
optional_cents_standalone = pynini.closure(
delete_space
+ pynutil.delete("و")
+ pynini.closure(pynutil.delete(" "), 0, 1)
+ insert_space
+ cents_standalone,
0,
1,
)
graph_integer = (
pynutil.insert("integer_part: \"")
+ cardinal_graph
+ pynutil.insert("\"")
+ delete_extra_space
+ graph_unit
+ optional_cents_standalone
)
graph_integer_with_ar_cur = (
pynutil.insert("integer_part: \"")
+ cardinal_graph
+ pynutil.insert("\"")
+ delete_extra_space
+ graph_ar_cur
)
graph_decimal = pynutil.insert("currency: \"$\" integer_part: \"0\" ") + cents_standalone
final_graph = graph_integer | graph_integer_with_ar_cur | graph_decimal
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ar/taggers/money.py |
# Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# 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.
import pynini
from nemo_text_processing.text_normalization.ar.graph_utils import NEMO_SPACE, GraphFst
from pynini.lib import pynutil
class CardinalFst(GraphFst):
"""
Finite state transducer for classifying cardinals
e.g. سالب تسعة وتسعون -> cardinal { integer: "99" negative: "-" } }
Numbers below thirteen are not converted.
Args:
tn_cardinal: cardinal FST for TN
"""
def __init__(self, tn_cardinal):
super().__init__(name="cardinal", kind="classify")
self.graph = pynini.invert(tn_cardinal.cardinal_numbers).optimize()
optional_minus_graph = pynini.closure(
pynutil.insert("negative: ") + pynini.cross("سالب", '"-"') + NEMO_SPACE, 0, 1,
)
final_graph = optional_minus_graph + pynutil.insert('integer: "') + self.graph + pynutil.insert('"')
final_graph = self.add_tokens(final_graph)
self.fst = final_graph.optimize()
| NeMo-text-processing-main | nemo_text_processing/inverse_text_normalization/ar/taggers/cardinal.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.