SinaTools 0.1.4__py2.py3-none-any.whl → 0.1.7__py2.py3-none-any.whl

nlptools/arabiner/data/datasets.py

@@ -1,146 +0,0 @@
-import logging
-import torch
-from torch.utils.data import Dataset
-from torch.nn.utils.rnn import pad_sequence
-from nlptools.arabiner.data.transforms import (
-    BertSeqTransform,
-    NestedTagsTransform
-)
-
-logger = logging.getLogger(__name__)
-
-
-class Token:
-    def __init__(self, text=None, pred_tag=None, gold_tag=None):
-        """
-        Token object to hold token attributes
-        :param text: str
-        :param pred_tag: str
-        :param gold_tag: str
-        """
-        self.text = text
-        self.gold_tag = gold_tag
-        self.pred_tag = pred_tag
-        self.subwords = None
-
-    @property
-    def subwords(self):
-        return self._subwords
-
-    @subwords.setter
-    def subwords(self, value):
-        self._subwords = value
-
-    def __str__(self):
-        """
-        Token text representation
-        :return: str
-        """
-        gold_tags = "|".join(self.gold_tag)
-        pred_tags = "|".join([pred_tag["tag"] for pred_tag in self.pred_tag])
-
-        if self.gold_tag:
-            r = f"{self.text}\t{gold_tags}\t{pred_tags}"
-        else:
-            r = f"{self.text}\t{pred_tags}"
-
-        return r
-
-
-class DefaultDataset(Dataset):
-    def __init__(
-        self,
-        examples=None,
-        vocab=None,
-        bert_model="aubmindlab/bert-base-arabertv2",
-        max_seq_len=512,
-    ):
-        """
-        The dataset that used to transform the segments into training data
-        :param examples: list[[tuple]] - [[(token, tag), (token, tag), ...], [(token, tag), ...]]
-                         You can get generate examples from -- arabiner.data.dataset.parse_conll_files
-        :param vocab: vocab object containing indexed tags and tokens
-        :param bert_model: str - BERT model
-        :param: int - maximum sequence length
-        """
-        self.transform = BertSeqTransform(bert_model, vocab, max_seq_len=max_seq_len)
-        self.examples = examples
-        self.vocab = vocab
-
-    def __len__(self):
-        return len(self.examples)
-
-    def __getitem__(self, item):
-        subwords, tags, tokens, valid_len = self.transform(self.examples[item])
-        return subwords, tags, tokens, valid_len
-
-    def collate_fn(self, batch):
-        """
-        Collate function that is called when the batch is called by the trainer
-        :param batch: Dataloader batch
-        :return: Same output as the __getitem__ function
-        """
-        subwords, tags, tokens, valid_len = zip(*batch)
-
-        # Pad sequences in this batch
-        # subwords and tokens are padded with zeros
-        # tags are padding with the index of the O tag
-        subwords = pad_sequence(subwords, batch_first=True, padding_value=0)
-        tags = pad_sequence(
-            tags, batch_first=True, padding_value=self.vocab.tags[0].get_stoi()["O"]
-        )
-        return subwords, tags, tokens, valid_len
-
-
-class NestedTagsDataset(Dataset):
-    def __init__(
-        self,
-        examples=None,
-        vocab=None,
-        bert_model="aubmindlab/bert-base-arabertv2",
-        max_seq_len=512,
-    ):
-        """
-        The dataset that used to transform the segments into training data
-        :param examples: list[[tuple]] - [[(token, tag), (token, tag), ...], [(token, tag), ...]]
-                         You can get generate examples from -- arabiner.data.dataset.parse_conll_files
-        :param vocab: vocab object containing indexed tags and tokens
-        :param bert_model: str - BERT model
-        :param: int - maximum sequence length
-        """
-        self.transform = NestedTagsTransform(
-            bert_model, vocab, max_seq_len=max_seq_len
-        )
-        self.examples = examples
-        self.vocab = vocab
-
-    def __len__(self):
-        return len(self.examples)
-
-    def __getitem__(self, item):
-        subwords, tags, tokens, masks, valid_len = self.transform(self.examples[item])
-        return subwords, tags, tokens, masks, valid_len
-
-    def collate_fn(self, batch):
-        """
-        Collate function that is called when the batch is called by the trainer
-        :param batch: Dataloader batch
-        :return: Same output as the __getitem__ function
-        """
-        subwords, tags, tokens, masks, valid_len = zip(*batch)
-
-        # Pad sequences in this batch
-        # subwords and tokens are padded with zeros
-        # tags are padding with the index of the O tag
-        subwords = pad_sequence(subwords, batch_first=True, padding_value=0)
-
-        masks = [torch.nn.ConstantPad1d((0, subwords.shape[-1] - tag.shape[-1]), 0)(mask)
-                 for tag, mask in zip(tags, masks)]
-        masks = torch.cat(masks)
-
-        # Pad the tags, do the padding for each tag type
-        tags = [torch.nn.ConstantPad1d((0, subwords.shape[-1] - tag.shape[-1]), vocab.get_stoi()["<pad>"])(tag)
-                for tag, vocab in zip(tags, self.vocab.tags[1:])]
-        tags = torch.cat(tags)
-
-        return subwords, tags, tokens, masks, valid_len

nlptools/arabiner/data/transforms.py

@@ -1,118 +0,0 @@
-import torch
-from transformers import BertTokenizer
-from functools import partial
-import re
-import itertools
-from nlptools.arabiner.data import datasets
-class BertSeqTransform:
-    def __init__(self, bert_model, vocab, max_seq_len=512):
-        self.tokenizer = BertTokenizer.from_pretrained(bert_model)
-        self.encoder = partial(
-            self.tokenizer.encode,
-            max_length=max_seq_len,
-            truncation=True,
-        )
-        self.max_seq_len = max_seq_len
-        self.vocab = vocab
-
-    def __call__(self, segment):
-        subwords, tags, tokens = list(), list(), list()
-        unk_token = datasets.Token(text="UNK")
-
-        for token in segment:
-            token_subwords = self.encoder(token.text)[1:-1]
-            subwords += token_subwords
-            tags += [self.vocab.tags[0].get_stoi()[token.gold_tag[0]]] + [self.vocab.tags[0].get_stoi()["O"]] * (len(token_subwords) - 1)
-            tokens += [token] + [unk_token] * (len(token_subwords) - 1)
-
-        # Truncate to max_seq_len
-        if len(subwords) > self.max_seq_len - 2:
-            text = " ".join([t.text for t in tokens if t.text != "UNK"])
-          
-            subwords = subwords[:self.max_seq_len - 2]
-            tags = tags[:self.max_seq_len - 2]
-            tokens = tokens[:self.max_seq_len - 2]
-
-        subwords.insert(0, self.tokenizer.cls_token_id)
-        subwords.append(self.tokenizer.sep_token_id)
-
-        tags.insert(0, self.vocab.tags[0].get_stoi()["O"])
-        tags.append(self.vocab.tags[0].get_stoi()["O"])
-
-        tokens.insert(0, unk_token)
-        tokens.append(unk_token)
-
-        return torch.LongTensor(subwords), torch.LongTensor(tags), tokens, len(tokens)
-
-
-class NestedTagsTransform:
-    def __init__(self, bert_model, vocab, max_seq_len=512):
-        self.tokenizer = BertTokenizer.from_pretrained(bert_model)
-        self.encoder = partial(
-            self.tokenizer.encode,
-            max_length=max_seq_len,
-            truncation=True,
-        )
-        self.max_seq_len = max_seq_len
-        self.vocab = vocab
-
-    def __call__(self, segment):
-        tags, tokens, subwords = list(), list(), list()
-        unk_token = datasets.Token(text="UNK")
-
-        # Encode each token and get its subwords and IDs
-        for token in segment:
-            token.subwords = self.encoder(token.text)[1:-1]
-            subwords += token.subwords
-            tokens += [token] + [unk_token] * (len(token.subwords ) - 1)
-
-        # Construct the labels for each tag type
-        # The sequence will have a list of tags for each type
-        # The final tags for a sequence is a matrix NUM_TAG_TYPES x SEQ_LEN
-        # Example:
-        #   [
-        #       [O,     O,     B-PERS, I-PERS, O, O, O]
-        #       [B-ORG, I-ORG, O,      O,      O, O, O]
-        #       [O,     O,     O,      O,      O, O, B-GPE]
-        #   ]
-        for vocab in self.vocab.tags[1:]:
-            vocab_tags = "|".join([t for t in vocab.get_itos() if "-" in t])
-            r = re.compile(vocab_tags)
-
-            # This is really messy
-            # For a given token we find a matching tag_name, BUT we might find
-            # multiple matches (i.e. a token can be labeled B-ORG and I-ORG) in this
-            # case we get only the first tag as we do not have overlapping of same type
-            single_type_tags = [[(list(filter(r.match, token.gold_tag))
-                                or ["O"])[0]] + ["O"] * (len(token.subwords) - 1)
-                                for token in segment]
-            single_type_tags = list(itertools.chain(*single_type_tags))
-            tags.append([vocab.get_stoi()[tag] for tag in single_type_tags])
-
-        # Truncate to max_seq_len
-        if len(subwords) > self.max_seq_len - 2:
-            text = " ".join([t.text for t in tokens if t.text != "UNK"])
-          
-            subwords = subwords[:self.max_seq_len - 2]
-            tags = [t[:self.max_seq_len - 2] for t in tags]
-            tokens = tokens[:self.max_seq_len - 2]
-
-        # Add dummy token at the start end of sequence
-        tokens.insert(0, unk_token)
-        tokens.append(unk_token)
-
-        # Add CLS and SEP at start end of subwords
-        subwords.insert(0, self.tokenizer.cls_token_id)
-        subwords.append(self.tokenizer.sep_token_id)
-        subwords = torch.LongTensor(subwords)
-
-        # Add "O" tags for the first and last subwords
-        tags = torch.Tensor(tags)
-        tags = torch.column_stack((
-            torch.Tensor([vocab.get_stoi()["O"] for vocab in self.vocab.tags[1:]]),
-            tags,
-            torch.Tensor([vocab.get_stoi()["O"] for vocab in self.vocab.tags[1:]]),
-        )).unsqueeze(0)
-
-        mask = torch.ones_like(tags)
-        return subwords, tags, tokens, mask, len(tokens)

nlptools/arabiner/nn/BaseModel.py

@@ -1,22 +0,0 @@
-from torch import nn
-from transformers import BertModel
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class BaseModel(nn.Module):
-    def __init__(self,
-                 bert_model="aubmindlab/bert-base-arabertv2",
-                 num_labels=2,
-                 dropout=0.1,
-                 num_types=0):
-        super().__init__()
-
-        self.bert_model = bert_model
-        self.num_labels = num_labels
-        self.num_types = num_types
-        self.dropout = dropout
-
-        self.bert = BertModel.from_pretrained(bert_model)
-        self.dropout = nn.Dropout(dropout)

nlptools/arabiner/nn/BertNestedTagger.py

@@ -1,34 +0,0 @@
-import torch
-import torch.nn as nn
-from nlptools.arabiner.nn import BaseModel
-
-
-class BertNestedTagger(BaseModel):
-    def __init__(self, **kwargs):
-        super(BertNestedTagger, self).__init__(**kwargs)
-
-        self.max_num_labels = max(self.num_labels)
-        classifiers = [nn.Linear(768, num_labels) for num_labels in self.num_labels]
-        self.classifiers = torch.nn.Sequential(*classifiers)
-
-    def forward(self, x):
-        y = self.bert(x)
-        y = self.dropout(y["last_hidden_state"])
-        output = list()
-
-        for i, classifier in enumerate(self.classifiers):
-            logits = classifier(y)
-
-            # Pad logits to allow Multi-GPU/DataParallel training to work
-            # We will truncate the padded dimensions when we compute the loss in the trainer
-            logits = torch.nn.ConstantPad1d((0, self.max_num_labels - logits.shape[-1]), 0)(logits)
-            output.append(logits)
-
-        # Return tensor of the shape B x T x L x C
-        # B: batch size
-        # T: sequence length
-        # L: number of tag types
-        # C: number of classes per tag type
-        output = torch.stack(output).permute((1, 2, 0, 3))
-        return output
-

nlptools/arabiner/nn/BertSeqTagger.py

@@ -1,17 +0,0 @@
-import torch.nn as nn
-from transformers import BertModel
-
-
-class BertSeqTagger(nn.Module):
-    def __init__(self, bert_model, num_labels=2, dropout=0.1):
-        super().__init__()
-
-        self.bert = BertModel.from_pretrained(bert_model)
-        self.dropout = nn.Dropout(dropout)
-        self.linear = nn.Linear(768, num_labels)
-
-    def forward(self, x):
-        y = self.bert(x)
-        y = self.dropout(y["last_hidden_state"])
-        logits = self.linear(y)
-        return logits

nlptools/arabiner/nn/__init__.py

@@ -1,3 +0,0 @@
-from nlptools.arabiner.nn.BaseModel import BaseModel
-from nlptools.arabiner.nn.BertSeqTagger import BertSeqTagger
-from nlptools.arabiner.nn.BertNestedTagger import BertNestedTagger

nlptools/arabiner/trainers/BaseTrainer.py

@@ -1,117 +0,0 @@
-import os
-import torch
-import logging
-import natsort
-import glob
-
-logger = logging.getLogger(__name__)
-
-
-class BaseTrainer:
-    def __init__(
-        self,
-        model=None,
-        max_epochs=50,
-        optimizer=None,
-        scheduler=None,
-        loss=None,
-        train_dataloader=None,
-        val_dataloader=None,
-        test_dataloader=None,
-        log_interval=10,
-        summary_writer=None,
-        output_path=None,
-        clip=5,
-        patience=5
-    ):
-        self.model = model
-        self.max_epochs = max_epochs
-        self.train_dataloader = train_dataloader
-        self.val_dataloader = val_dataloader
-        self.test_dataloader = test_dataloader
-        self.optimizer = optimizer
-        self.scheduler = scheduler
-        self.loss = loss
-        self.log_interval = log_interval
-        self.summary_writer = summary_writer
-        self.output_path = output_path
-        self.current_timestep = 0
-        self.current_epoch = 0
-        self.clip = clip
-        self.patience = patience
-
-    def tag(self, dataloader, is_train=True):
-        """
-        Given a dataloader containing segments, predict the tags
-        :param dataloader: torch.utils.data.DataLoader
-        :param is_train: boolean - True for training model, False for evaluation
-        :return: Iterator
-                    subwords (B x T x NUM_LABELS)- torch.Tensor - BERT subword ID
-                    gold_tags (B x T x NUM_LABELS) - torch.Tensor - ground truth tags IDs
-                    tokens - List[arabiner.data.dataset.Token] - list of tokens
-                    valid_len (B x 1) - int - valiud length of each sequence
-                    logits (B x T x NUM_LABELS) - logits for each token and each tag
-        """
-        for subwords, gold_tags, tokens, valid_len in dataloader:
-            self.model.train(is_train)
-
-            if torch.cuda.is_available():
-                subwords = subwords.cuda()
-                gold_tags = gold_tags.cuda()
-
-            if is_train:
-                self.optimizer.zero_grad()
-                logits = self.model(subwords)
-            else:
-                with torch.no_grad():
-                    logits = self.model(subwords)
-
-            yield subwords, gold_tags, tokens, valid_len, logits
-
-    def segments_to_file(self, segments, filename):
-        """
-        Write segments to file
-        :param segments: [List[arabiner.data.dataset.Token]] - list of list of tokens
-        :param filename: str - output filename
-        :return: None
-        """
-        with open(filename, "w") as fh:
-            results = "\n\n".join(["\n".join([t.__str__() for t in segment]) for segment in segments])
-            fh.write("Token\tGold Tag\tPredicted Tag\n")
-            fh.write(results)
-            logging.info("Predictions written to %s", filename)
-
-    def save(self):
-        """
-        Save model checkpoint
-        :return:
-        """
-        filename = os.path.join(
-            self.output_path,
-            "checkpoints",
-            "checkpoint_{}.pt".format(self.current_epoch),
-        )
-
-        checkpoint = {
-            "model": self.model.state_dict(),
-            "optimizer": self.optimizer.state_dict(),
-            "epoch": self.current_epoch
-        }
-
-        logger.info("Saving checkpoint to %s", filename)
-        torch.save(checkpoint, filename)
-
-    def load(self, checkpoint_path):
-        """
-        Load model checkpoint
-        :param checkpoint_path: str - path/to/checkpoints
-        :return: None
-        """
-        checkpoint_path = natsort.natsorted(glob.glob(f"{checkpoint_path}/checkpoint_*.pt"))
-        checkpoint_path = checkpoint_path[-1]
-
-        logger.info("Loading checkpoint %s", checkpoint_path)
-
-        device = None if torch.cuda.is_available() else torch.device('cpu')
-        checkpoint = torch.load(checkpoint_path, map_location=device)
-        self.model.load_state_dict(checkpoint["model"])

nlptools/arabiner/trainers/BertNestedTrainer.py

@@ -1,203 +0,0 @@
-import os
-import logging
-import torch
-import numpy as np
-from nlptools.arabiner.trainers import BaseTrainer
-from nlptools.arabiner.utils.metrics import compute_nested_metrics
-
-logger = logging.getLogger(__name__)
-
-
-class BertNestedTrainer(BaseTrainer):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def train(self):
-        best_val_loss, test_loss = np.inf, np.inf
-        num_train_batch = len(self.train_dataloader)
-        num_labels = [len(v) for v in self.train_dataloader.dataset.vocab.tags[1:]]
-        patience = self.patience
-
-        for epoch_index in range(self.max_epochs):
-            self.current_epoch = epoch_index
-            train_loss = 0
-
-            for batch_index, (subwords, gold_tags, tokens, valid_len, logits) in enumerate(self.tag(
-                self.train_dataloader, is_train=True
-            ), 1):
-                self.current_timestep += 1
-
-                # Compute loses for each output
-                # logits = B x T x L x C
-                losses = [self.loss(logits[:, :, i, 0:l].view(-1, logits[:, :, i, 0:l].shape[-1]),
-                                    torch.reshape(gold_tags[:, i, :], (-1,)).long())
-                          for i, l in enumerate(num_labels)]
-
-                torch.autograd.backward(losses)
-
-                # Avoid exploding gradient by doing gradient clipping
-                torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip)
-
-                self.optimizer.step()
-                self.scheduler.step()
-                batch_loss = sum(l.item() for l in losses)
-                train_loss += batch_loss
-
-                if self.current_timestep % self.log_interval == 0:
-                    logger.info(
-                        "Epoch %d | Batch %d/%d | Timestep %d | LR %.10f | Loss %f",
-                        epoch_index,
-                        batch_index,
-                        num_train_batch,
-                        self.current_timestep,
-                        self.optimizer.param_groups[0]['lr'],
-                        batch_loss
-                    )
-
-            train_loss /= num_train_batch
-
-            logger.info("** Evaluating on validation dataset **")
-            val_preds, segments, valid_len, val_loss = self.eval(self.val_dataloader)
-            val_metrics = compute_nested_metrics(segments, self.val_dataloader.dataset.transform.vocab.tags[1:])
-
-            epoch_summary_loss = {
-                "train_loss": train_loss,
-                "val_loss": val_loss
-            }
-            epoch_summary_metrics = {
-                "val_micro_f1": val_metrics.micro_f1,
-                "val_precision": val_metrics.precision,
-                "val_recall": val_metrics.recall
-            }
-
-            logger.info(
-                "Epoch %d | Timestep %d | Train Loss %f | Val Loss %f | F1 %f",
-                epoch_index,
-                self.current_timestep,
-                train_loss,
-                val_loss,
-                val_metrics.micro_f1
-            )
-
-            if val_loss < best_val_loss:
-                patience = self.patience
-                best_val_loss = val_loss
-                logger.info("** Validation improved, evaluating test data **")
-                test_preds, segments, valid_len, test_loss = self.eval(self.test_dataloader)
-                self.segments_to_file(segments, os.path.join(self.output_path, "predictions.txt"))
-                test_metrics = compute_nested_metrics(segments, self.test_dataloader.dataset.transform.vocab.tags[1:])
-
-                epoch_summary_loss["test_loss"] = test_loss
-                epoch_summary_metrics["test_micro_f1"] = test_metrics.micro_f1
-                epoch_summary_metrics["test_precision"] = test_metrics.precision
-                epoch_summary_metrics["test_recall"] = test_metrics.recall
-
-                logger.info(
-                    f"Epoch %d | Timestep %d | Test Loss %f | F1 %f",
-                    epoch_index,
-                    self.current_timestep,
-                    test_loss,
-                    test_metrics.micro_f1
-                )
-
-                self.save()
-            else:
-                patience -= 1
-
-            # No improvements, terminating early
-            if patience == 0:
-                logger.info("Early termination triggered")
-                break
-
-            self.summary_writer.add_scalars("Loss", epoch_summary_loss, global_step=self.current_timestep)
-            self.summary_writer.add_scalars("Metrics", epoch_summary_metrics, global_step=self.current_timestep)
-
-    def tag(self, dataloader, is_train=True):
-        """
-        Given a dataloader containing segments, predict the tags
-        :param dataloader: torch.utils.data.DataLoader
-        :param is_train: boolean - True for training model, False for evaluation
-        :return: Iterator
-                    subwords (B x T x NUM_LABELS)- torch.Tensor - BERT subword ID
-                    gold_tags (B x T x NUM_LABELS) - torch.Tensor - ground truth tags IDs
-                    tokens - List[arabiner.data.dataset.Token] - list of tokens
-                    valid_len (B x 1) - int - valiud length of each sequence
-                    logits (B x T x NUM_LABELS) - logits for each token and each tag
-        """
-        for subwords, gold_tags, tokens, mask, valid_len in dataloader:
-            self.model.train(is_train)
-
-            if torch.cuda.is_available():
-                subwords = subwords.cuda()
-                gold_tags = gold_tags.cuda()
-
-            if is_train:
-                self.optimizer.zero_grad()
-                logits = self.model(subwords)
-            else:
-                with torch.no_grad():
-                    logits = self.model(subwords)
-
-            yield subwords, gold_tags, tokens, valid_len, logits
-
-    def eval(self, dataloader):
-        golds, preds, segments, valid_lens = list(), list(), list(), list()
-        num_labels = [len(v) for v in dataloader.dataset.vocab.tags[1:]]
-        loss = 0
-
-        for _, gold_tags, tokens, valid_len, logits in self.tag(
-            dataloader, is_train=False
-        ):
-            losses = [self.loss(logits[:, :, i, 0:l].view(-1, logits[:, :, i, 0:l].shape[-1]),
-                                torch.reshape(gold_tags[:, i, :], (-1,)).long())
-                      for i, l in enumerate(num_labels)]
-            loss += sum(losses)
-            preds += torch.argmax(logits, dim=3)
-            segments += tokens
-            valid_lens += list(valid_len)
-
-        loss /= len(dataloader)
-
-        # Update segments, attach predicted tags to each token
-        segments = self.to_segments(segments, preds, valid_lens, dataloader.dataset.vocab)
-
-        return preds, segments, valid_lens, loss
-
-    def infer(self, dataloader):
-        golds, preds, segments, valid_lens = list(), list(), list(), list()
-
-        for _, gold_tags, tokens, valid_len, logits in self.tag(
-            dataloader, is_train=False
-        ):
-            preds += torch.argmax(logits, dim=3)
-            segments += tokens
-            valid_lens += list(valid_len)
-
-        segments = self.to_segments(segments, preds, valid_lens, dataloader.dataset.vocab)
-        return segments
-
-    def to_segments(self, segments, preds, valid_lens, vocab):
-        if vocab is None:
-            vocab = self.vocab
-
-        tagged_segments = list()
-        tokens_stoi = vocab.tokens.get_stoi()
-        unk_id = tokens_stoi["UNK"]
-
-        for segment, pred, valid_len in zip(segments, preds, valid_lens):
-            # First, the token at 0th index [CLS] and token at nth index [SEP]
-            # Combine the tokens with their corresponding predictions
-            segment_pred = zip(segment[1:valid_len-1], pred[1:valid_len-1])
-
-            # Ignore the sub-tokens/subwords, which are identified with text being UNK
-            segment_pred = list(filter(lambda t: tokens_stoi[t[0].text] != unk_id, segment_pred))
-
-            # Attach the predicted tags to each token
-            list(map(lambda t: setattr(t[0], 'pred_tag', [{"tag": vocab.get_itos()[tag_id]}
-                                                     for tag_id, vocab in zip(t[1].int().tolist(), vocab.tags[1:])]), segment_pred))
-
-            # We are only interested in the tagged tokens, we do no longer need raw model predictions
-            tagged_segment = [t for t, _ in segment_pred]
-            tagged_segments.append(tagged_segment)
-
-        return tagged_segments