"""The IWSLT Challenge Dataset, adapted to punctuation as described by Ueffing et al. (2013)""" from enum import Enum from typing import Union from abc import abstractmethod import logging import itertools #import paired from xml.dom import minidom import nltk import datasets import numpy as np nltk.download("punkt") tknzr = nltk.tokenize.TweetTokenizer() _CITATION = """\ @inproceedings{Ueffing2013, title={Improved models for automatic punctuation prediction for spoken and written text}, author={B. Ueffing and M. Bisani and P. Vozila}, booktitle={INTERSPEECH}, year={2013} } @article{Federico2011, author = {M. Federico and L. Bentivogli and M. Paul and S. Stüker}, year = {2011}, month = {01}, pages = {}, title = {Overview of the IWSLT 2011 Evaluation Campaign}, journal = {Proceedings of the International Workshop on Spoken Language Translation (IWSLT), San Francisco, CA} } """ _DESCRIPTION = """\ Both manual transcripts and ASR outputs from the IWSLT2011 speech translation evalutation campaign are often used for the related \ punctuation annotation task. This dataset takes care of preprocessing said transcripts and automatically inserts punctuation marks \ given in the manual transcripts in the ASR outputs using Levenshtein aligment. """ _VERSION = "0.0.1" def window(a, w = 4, o = 2): sh = (a.size - w + 1, w) st = a.strides * 2 view = np.lib.stride_tricks.as_strided(a, strides = st, shape = sh)[0::o] return view.copy() class Punctuation(Enum): NONE = "" PERIOD = "" COMMA = "" QUESTION = "" class LabelSubword(Enum): IGNORE = "" NONE = "" class Task(Enum): TAGGING = 0 SEQ2SEQ = 1 class TaggingTask: """Treat punctuation prediction as a sequence tagging problem.""" def __eq__(self, other): return Task.TAGGING == other class IWSLT11Config(datasets.BuilderConfig): """The IWSLT11 Dataset.""" def __init__( self, task = TaggingTask(), segmented: bool = False, asr_or_ref: str = "ref", tokenizer = None, label_subword = LabelSubword.IGNORE, window_size = 120, window_stride = 60, **kwargs ): """BuilderConfig for IWSLT2011. Args: task: the task to prepare the dataset for. segmented: if segmentation present in IWSLT2011 should be respected. removes segmenation by default. **kwargs: keyword arguments forwarded to super. """ self.task = task self.window_size = window_size self.window_stride = window_stride self.segmented = segmented self.asr_or_ref = asr_or_ref self.punctuation = [ Punctuation.NONE, Punctuation.PERIOD, Punctuation.COMMA, Punctuation.QUESTION, label_subword.IGNORE ] self.label_subword = label_subword self.tokenizer = tokenizer super(IWSLT11Config, self).__init__(**kwargs) def __eq__(self, other): return True class IWSLT11(datasets.GeneratorBasedBuilder): """The IWSLT11 Dataset, adapted for punctuation prediction.""" BUILDER_CONFIGS = [ IWSLT11Config(name="ref", asr_or_ref="ref"), IWSLT11Config(name="asr", asr_or_ref="asr"), ] def __init__(self, *args, **kwargs): if 'label_subword' in kwargs: label_subword = kwargs['label_subword'] if isinstance(label_subword, str): if 'ignore' == label_subword.lower(): label_subword = LabelSubword.IGNORE elif 'none' == label_subword.lower(): label_subword = LabelSubword.NONE kwargs['label_subword'] = label_subword super(IWSLT11, self).__init__(*args, **kwargs) def _info(self): if self.config.task == Task.TAGGING: return datasets.DatasetInfo( description=_DESCRIPTION, features=datasets.Features( { "ids": datasets.Sequence(datasets.Value("int32")), "tokens": datasets.Sequence(datasets.Value("int32")), "labels": datasets.Sequence( datasets.features.ClassLabel( names=[p.name for p in self.config.punctuation] ) ), } ), supervised_keys=None, homepage="http://iwslt2011.org/doku.php", citation=_CITATION, version=_VERSION, ) def _split_generators(self, dl_manager): """Returns SplitGenerators.""" urls_to_download = { "train": "https://raw.githubusercontent.com/IsaacChanghau/neural_sequence_labeling/master/data/raw/LREC_converted/train.txt", "valid": "https://github.com/IsaacChanghau/neural_sequence_labeling/blob/master/data/raw/LREC_converted/dev.txt?raw=true", "test_ref": "https://github.com/IsaacChanghau/neural_sequence_labeling/raw/master/data/raw/LREC_converted/ref.txt", "test_asr": "https://github.com/IsaacChanghau/neural_sequence_labeling/raw/master/data/raw/LREC_converted/asr.txt", } files = dl_manager.download_and_extract(urls_to_download) if self.config.asr_or_ref == "asr": return [ datasets.SplitGenerator( name=datasets.Split.TRAIN, gen_kwargs={ "filepath": files["train"] }, ), datasets.SplitGenerator( name=datasets.Split.VALIDATION, gen_kwargs={ "filepath": files["valid"] }, ), datasets.SplitGenerator( name=datasets.Split.TEST, gen_kwargs={ "filepath": files["test_asr"] }, ), ] else: return [ datasets.SplitGenerator( name=datasets.Split.TRAIN, gen_kwargs={ "filepath": files["train"] }, ), datasets.SplitGenerator( name=datasets.Split.VALIDATION, gen_kwargs={ "filepath": files["valid"] }, ), datasets.SplitGenerator( name=datasets.Split.TEST, gen_kwargs={ "filepath": files["test_ref"] }, ), ] def _generate_examples(self, filepath): logging.info("⏳ Generating examples from = %s", filepath) text = open(filepath).read() text = ( text .replace(',COMMA', ',') .replace('.PERIOD', '.') .replace('?QUESTIONMARK', '?') ) tokens = [] labels = [] for token in tknzr.tokenize(text): if token in [',', '.', '?']: if ',' in token: labels[-1] = Punctuation.COMMA if '.' in token: labels[-1] = Punctuation.PERIOD if '?' in token: labels[-1] = Punctuation.QUESTION else: labels.append(Punctuation.NONE) tokens.append(token) tokens = np.array(tokens) labels = np.array(labels) token_len = len(tokens) assert len(tokens) == len(labels) if self.config.task == Task.TAGGING: def apply_window(l): return window( l, self.config.window_size, self.config.window_stride ) ids = apply_window(np.arange(len(tokens))) tokens = apply_window(tokens) tokens = self.config.tokenizer( [t.tolist() for t in tokens], is_split_into_words=True, return_offsets_mapping=True, padding=True, truncation=True, max_length=int(self.config.window_size*2), pad_to_multiple_of=int(self.config.window_size*2) ) labels = apply_window(labels) for i, (ids, labels) in enumerate(zip(ids, labels)): if self.config.tokenizer is None: raise ValueError('tokenizer argument has to be passed to load_dataset') else: words = tokens[i].words input_ids = tokens['input_ids'][i] offsets = np.array(tokens['offset_mapping'][i]) enc_labels = np.array([self.config.label_subword.name]*len(offsets), dtype=object) count = 0 for j, word_id in enumerate(words): if word_id is not None and (j == 0 or words[j-1] != word_id): enc_labels[j] = labels[count].name count += 1 elif input_ids[j] == self.config.tokenizer.pad_token_id: enc_labels[j] = LabelSubword.IGNORE.name labels = enc_labels yield i, { "ids": ids, "tokens": input_ids, "labels": labels, } logging.info(f"Loaded number of tokens = {token_len}")