|
"""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 |
|
|
|
|
|
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 = "<none>" |
|
PERIOD = "<period>" |
|
COMMA = "<comma>" |
|
QUESTION = "<question>" |
|
|
|
class LabelSubword(Enum): |
|
IGNORE = "<ignore>" |
|
NONE = "<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}") |
