Upload 18 files

config.json

@@ -0,0 +1,82 @@
+{
+    "return_dict": true,
+    "output_hidden_states": false,
+    "output_attentions": false,
+    "torchscript": false,
+    "torch_dtype": null,
+    "use_bfloat16": false,
+    "tf_legacy_loss": false,
+    "pruned_heads": {},
+    "tie_word_embeddings": true,
+    "is_encoder_decoder": false,
+    "is_decoder": false,
+    "cross_attention_hidden_size": null,
+    "add_cross_attention": false,
+    "tie_encoder_decoder": false,
+    "max_length": 20,
+    "min_length": 0,
+    "do_sample": false,
+    "early_stopping": false,
+    "num_beams": 1,
+    "num_beam_groups": 1,
+    "diversity_penalty": 0.0,
+    "temperature": 1.0,
+    "top_k": 50,
+    "top_p": 1.0,
+    "typical_p": 1.0,
+    "repetition_penalty": 1.0,
+    "length_penalty": 1.0,
+    "no_repeat_ngram_size": 0,
+    "encoder_no_repeat_ngram_size": 0,
+    "bad_words_ids": null,
+    "num_return_sequences": 1,
+    "chunk_size_feed_forward": 0,
+    "output_scores": false,
+    "return_dict_in_generate": false,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "remove_invalid_values": false,
+    "exponential_decay_length_penalty": null,
+    "suppress_tokens": null,
+    "begin_suppress_tokens": null,
+    "architectures": [
+        "BertForMaskedLM"
+    ],
+    "finetuning_task": null,
+    "id2label": {
+        "0": "LABEL_0",
+        "1": "LABEL_1"
+    },
+    "label2id": {
+        "LABEL_0": 0,
+        "LABEL_1": 1
+    },
+    "tokenizer_class": null,
+    "prefix": null,
+    "bos_token_id": null,
+    "pad_token_id": 0,
+    "eos_token_id": null,
+    "sep_token_id": null,
+    "decoder_start_token_id": null,
+    "task_specific_params": null,
+    "problem_type": null,
+    "_name_or_path": "",
+    "transformers_version": "4.35.2",
+    "gradient_checkpointing": false,
+    "model_type": "bert",
+    "vocab_size": 30522,
+    "hidden_size": 768,
+    "num_hidden_layers": 12,
+    "num_attention_heads": 12,
+    "hidden_act": "gelu",
+    "intermediate_size": 3072,
+    "hidden_dropout_prob": 0.1,
+    "attention_probs_dropout_prob": 0.1,
+    "max_position_embeddings": 512,
+    "type_vocab_size": 2,
+    "initializer_range": 0.02,
+    "layer_norm_eps": 1e-12,
+    "position_embedding_type": "absolute",
+    "use_cache": true,
+    "classifier_dropout": null
+}

data_loader.py

@@ -0,0 +1,43 @@
+import json
+import os
+from typing import Dict, List, Union
+import sys
+
+project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(project_dir)
+
+from utils import structure_data
+
+
+def load_dataset(dataset_name: str) -> Dict[str, Union[str, List[str]]]:
+    """
+    Load training dataset or validation dataset.
+
+    Args:
+        dataset_name (str): The name of the dataset. Should be either 'training_dataset' or 'validation_dataset'.
+
+    Returns:
+        dataset (Dict[str, Union[str. List[str]]]): A dictionary representing the 
+        loaded dataset with keys 'text', 'ner', and 'intent'.
+
+    Raises:
+        ValueError: If the provided dataset_name is not one of the valid_names.
+        FileNotFoundError: If the dataset file is not found in the specified path.
+    """
+
+    valid_names = ["training_dataset", "validation_dataset"]
+
+    if dataset_name not in valid_names:
+        raise ValueError(f"Invalid dataset name. Expected one of {valid_names}, got {dataset_name}")
+    
+    path = f"{dataset_name}.json"
+
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Dataset file not found at {path}")
+    
+    with open(path, 'r') as f:
+        dataset = json.load(f)
+
+    dataset = structure_data(dataset)
+
+    return dataset

data_module.py

@@ -0,0 +1,44 @@
+import pytorch_lightning as pl
+from torch.utils.data import DataLoader
+import torch
+from typing import Dict
+
+
+class DataModule(pl.LightningDataModule):
+    """
+    Lightning DataModule for handling training and validation datasets.
+
+    Args:
+        training_set (torch.utils.data.Dataset): Training dataset.
+        validation_set (torch.utils.data.Dataset): Validation dataset.
+
+    Attributes:
+        training_set (torch.utils.data.Dataset): Training dataset.
+        validation_set (torch.utils.data.Dataset): Validation dataset.
+        train_ds (torch.utils.data.Dataset): Alias for the training dataset during setup.
+        val_ds (torch.utils.data.Dataset): Alias for the validation dataset during setup.
+
+    Methods:
+        setup(self, stage: Optional[str] = None):
+            Setup method to load and preprocess datasets.
+
+        train_dataloader(self) -> DataLoader:
+            Return a DataLoader for the training dataset.
+
+        val_dataloader(self) -> DataLoader:
+            Return a DataLoader for the validation dataset.
+    """
+    def __init__(self, training_set, validation_set):
+        super().__init__()
+        self.training_set = training_set
+        self.validation_set = validation_set
+
+    def setup(self, stage: str):
+        self.train_ds = self.training_set
+        self.val_ds = self.validation_set
+
+    def train_dataloader(self):
+        return DataLoader(self.train_ds, batch_size=1, shuffle=True)
+
+    def val_dataloader(self):
+        return DataLoader(self.val_ds, batch_size=1, shuffle=False)

data_processing.py

@@ -0,0 +1,88 @@
+from torch.utils.data import DataLoader, Dataset
+import torch
+from transformers import BertTokenizerFast, BertModel
+from transformers import BertConfig, BertPreTrainedModel
+import numpy as np
+from typing import Dict, List, Union, Tuple
+from utils import ner_labels_to_ids, intent_labels_to_ids, structure_data
+
+class tokenized_dataset(Dataset):
+    """
+    A Pytorch Dataset for tokenizing and encoding text data for a BERT-based model.
+
+    Args:
+        dataset (dict): A dictionary containing 'text', 'ner', and 'intent' keys.
+        tokenizer (BertTokenizerFast): A tokenizer for processing text input.
+        max_len (int, optionl): Maximum length of tokenized sequences (default: 128).
+
+    Attributes:
+        len (int): Number of samples in the dataset.
+
+    Methods:
+        __getitem__(self, index: int) -> Dict[str, torch.Tensor]:
+            Retrieve and preprocess a single sample from the dataset.
+
+        __len__(self) -> int:
+            Get the total number of samples int the dataset.
+
+    Returns:
+        Dict[str, torch.Tensor]: A dictionary containing tokenized and encoded text, NER and intent labels.
+    """
+    def __init__(self, dataset: Dict[str, List[str]], tokenizer: BertTokenizerFast, max_len: int = 128):
+        self.len = len(dataset['text'])
+        self.ner_labels_to_ids = ner_labels_to_ids()
+        self.intent_labels_to_ids = intent_labels_to_ids()
+        self.text = dataset['text']
+        self.intent = dataset['intent']
+        self.ner = dataset['entities']
+        self.tokenizer = tokenizer()
+        self.max_len = max_len
+
+    def __getitem__(self, index: int) -> Dict[str, torch.Tensor]:
+        # step 1: get the sentence, ner label, and intent_label
+        sentence = self.text[index].strip()
+        intent_label = self.intent[index].strip()
+        ner_labels = self.ner[index]
+
+        # step 2: use tokenizer to encode a sentence (includes padding/truncation up to max length)
+        # BertTokenizerFast provides a handy "return_offsets_mapping" which highlights where each token starts and ends
+        encoding = self.tokenizer(
+            sentence,
+            return_offsets_mapping=True,
+            padding='max_length',
+            truncation=True,
+            max_length=self.max_len
+        )
+
+        # step 3: create ner token labels only for first word pieces of each tokenized word
+        tokenized_ner_labels = [self.ner_labels_to_ids[label] for label in ner_labels]
+        # create an empty array of -100 of length max_length
+        encoded_ner_labels = np.ones(len(encoding['offset_mapping']), dtype=int) * -100
+
+        # set only labels whose first offset position is 0 and the second is not 0
+        i = 0
+        prev = -1
+        for idx, mapping in enumerate(encoding['offset_mapping']):
+            if mapping[0] == mapping[1] == 0:
+                continue
+            if mapping[0] != prev:
+                # overwrite label
+                encoded_ner_labels[idx] = tokenized_ner_labels[i]
+                prev = mapping[1]
+                i += 1
+            else:
+                prev = mapping[1]
+
+        # create intent token labels
+        tokenized_intent_label = self.intent_labels_to_ids[intent_label]
+
+        # step 4: turn everything into Pytorch tensors
+        item = {key: torch.as_tensor(val) for key, val in encoding.items()}
+        item['ner_labels'] = torch.as_tensor(encoded_ner_labels)
+        item['intent_labels'] = torch.as_tensor(tokenized_intent_label)
+
+        return item
+
+    def __len__(self) -> int:
+        return self.len
+    

inference.py

@@ -0,0 +1,125 @@
+import torch
+import os
+import sys
+
+project_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(project_dir)
+
+from model import MultiTaskBertModel
+from data_loader import load_dataset
+from utils import bert_config, tokenizer, intent_ids_to_labels, intent_labels_to_ids
+
+
+def load_model(model_path):
+    """
+    Load the pre-trained model weights from the specified path.
+
+    Args:
+        model_path (str): Path to the pre-trained model weights.
+
+    Returns:
+        model (MultiTaskBertModel): Loaded model with pre-trained weights.
+    """
+    # Initialize model with configuration and dataset information
+    config = bert_config()
+    dataset = load_dataset("training_dataset")
+    model = MultiTaskBertModel(config, dataset)
+
+    # Load the model weights from the specified path
+    model.load_state_dict(torch.load(model_path))
+
+    model.eval()
+
+    return model
+
+def preprocess_input(input_data):
+    """
+    Preprocess the input text data for inference.
+
+    Args:
+        input_data (str): Input text data to be preprocessed.
+
+    Returns:
+        input_ids (torch.Tensor): Tensor of input IDs after tokenization.
+        attention_mask (torch.Tensor): Tensor of attention mask indicating input tokens.
+        offset_mapping (torch.Tensor): Tensor of offset mappings for input tokens.
+    """
+    # Tokenize the input text and get offset mappings
+    tok = tokenizer()
+    preprocessed_input = tok(input_data,
+                                   return_offsets_mapping=True,
+                                   padding='max_length',
+                                   truncation=True,
+                                   max_length=128)
+
+    # Convert preprocessed inputs to PyTorch tensors
+    input_ids = torch.tensor([preprocessed_input['input_ids']])
+    attention_mask = torch.tensor([preprocessed_input['attention_mask']])
+    offset_mapping = torch.tensor(preprocessed_input['offset_mapping'])
+    return input_ids, attention_mask, offset_mapping
+
+def perform_inference(model, input_ids, attention_mask):
+
+    with torch.no_grad():
+
+        ner_logits, intent_logits = model.forward(input_ids, attention_mask)
+
+    return ner_logits, intent_logits
+    
+def align_ner_predictions_with_input(predictions, offset_mapping, input_text):
+    aligned_predictions = []
+    current_word_idx = 0
+
+    # Iterate through each prediction and its offset mapping
+    for prediction, (start, end) in zip(predictions, offset_mapping):
+        if start == end:
+            continue
+        # Find the corresponding word in the input text
+        word = input_text[start:end]
+
+        # Check if the current word is a special token or part of padding
+        if not word.strip():
+            continue
+
+        # Assign the prediction to the word
+        aligned_predictions.append((word, prediction))
+    
+    return aligned_predictions
+
+def convert_intent_to_label(intent_logit):
+    labels = intent_labels_to_ids()
+    intent_labels = intent_ids_to_labels(labels)
+    return intent_labels[int(intent_logit)]
+
+
+def main(input_data):
+    """
+    Main function to perform inference using the pre-trained model.
+    """
+    # Load the pre-trained model
+    model_path = "pytorch_model.bin"
+    model = load_model(model_path)
+
+    # Preprocess the input text
+    input_ids, attention_mask, offset_mapping = preprocess_input(input_data)
+
+    # Perform inference using the pre-trained model
+    ner_logits, intent_logits = perform_inference(model, input_ids, attention_mask)
+
+    # Post-process the model outputs and print the results
+    ner_logits = torch.argmax(ner_logits.view(-1, 9), dim=1)
+    intent_logits = torch.argmax(intent_logits)
+
+    ner_logits = align_ner_predictions_with_input(ner_logits, offset_mapping, input_data)
+    intent_label = convert_intent_to_label(intent_logits)
+
+    return ner_logits, intent_label
+    
+
+if __name__ == "__main__":
+
+    input_data = "I want to schedule a meeting for the 15th of this month at 2:30 PM."
+    ner_logits, intent_label = main(input_data)
+
+    print(f"Ner logits: {ner_logits}")
+    print(f"Intent logits: {intent_label}")

intent_labels.json

@@ -0,0 +1 @@
+{"'Schedule Appointment'": 0, "'Schedule Meeting'": 1, "'Set Alarm'": 2, "'Set Reminder'": 3, "'Set Timer'": 4}

metrics.py

@@ -0,0 +1,46 @@
+import torch
+from torchmetrics import Metric
+
+class MyAccuracy(Metric):
+    """
+    Accuracy metric costomized for handling sequences with padding.
+
+    Methods:
+        update(self, logits, labels, num_labels): Update the accuracy based on 
+        model predictions and ground truth labels.
+
+        compute(self): Compute the accuracy.
+
+    Attributes:
+        total (torch.Tensor): Total number of non-padding elements.
+        correct (torch.Tensor): Number of correctly predicted non-padding elements.
+    """
+    def __init__(self):
+        super().__init__()
+        self.add_state('total', default=torch.tensor(0), dist_reduce_fx='sum')
+        self.add_state('correct', default=torch.tensor(0), dist_reduce_fx='sum')
+
+    def update(self, logits: torch.Tensor, labels: torch.Tensor, num_labels: int) -> None:
+        """
+        Args:
+            logits (torch.Tensor): Model predictions.
+            labels (torch.Tensor): Ground truth labels.
+            num_labels (int): Number of unique labels.
+        """
+        flattened_targets = labels.view(-1) # shape (batch_size, sequence_len)
+        active_logits = logits.view(-1, num_labels) # shape (batch_size * sequence_len, num_labels)
+        flattened_predictions = torch.argmax(active_logits, axis=1) # shape (batch_size * sequence_len)
+
+        # compute accuracy only at active labels
+        active_accuracy = labels.view(-1) != -100 # shape (batch_size, sequnce_len)
+        ac_labels = torch.masked_select(flattened_targets, active_accuracy)
+        predictions = torch.masked_select(flattened_predictions, active_accuracy)
+
+        self.correct += torch.sum(ac_labels == predictions)
+        self.total += torch.numel(ac_labels)
+
+    def compute(self) -> torch.Tensor:
+        """
+        Calculate the accuracy.
+        """
+        return self.correct.float() / self.total.float()

model.py

@@ -0,0 +1,153 @@
+from transformers import BertModel
+import torch
+import onnx
+import pytorch_lightning as pl
+import wandb
+from metrics import MyAccuracy
+from utils import num_unique_labels
+from typing import Dict, Tuple, List, Optional
+
+class MultiTaskBertModel(pl.LightningModule):
+
+    """
+    Multi-task Bert model for Named Entity Recognition (NER) and Intent Classification
+
+    Args:
+        config (BertConfig): Bert model configuration.
+        dataset (Dict[str, Union[str, List[str]]]): A dictionary containing keys 'text', 'ner', and 'intent'.
+    """
+
+    def __init__(self, config, dataset):
+        super().__init__()
+
+        self.num_ner_labels, self.num_intent_labels = num_unique_labels(dataset)
+
+        self.dropout = torch.nn.Dropout(config.hidden_dropout_prob)
+
+        self.model = BertModel(config=config)
+
+        self.ner_classifier = torch.nn.Linear(config.hidden_size, self.num_ner_labels)
+        self.intent_classifier = torch.nn.Linear(config.hidden_size, self.num_intent_labels)
+
+        # log hyperparameters
+        self.save_hyperparameters()
+
+        self.accuracy = MyAccuracy()
+
+    def forward(self, input_ids: torch.Tensor, attention_mask: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor]:
+
+        """
+        Perform a forward pass through Multi-task Bert model.
+
+        Args:
+            input_ids (torch.Tensor, torch.shape: (batch, length_of_tokenized_sequences)): Input token IDs.
+            attention_mask (Optional[torch.Tensor]): Attention mask for input tokens.
+
+        Returns:
+            Tuple[torch.Tensor,torch.Tensor]: NER logits, Intent logits.
+        """
+
+        outputs = self.model(input_ids=input_ids, attention_mask=attention_mask)
+
+        sequence_output = outputs[0]
+        sequence_output = self.dropout(sequence_output)
+        ner_logits = self.ner_classifier(sequence_output)
+
+        pooled_output = outputs[1]
+        pooled_output = self.dropout(pooled_output)
+        intent_logits = self.intent_classifier(pooled_output)
+
+        return ner_logits, intent_logits
+
+    def training_step(self: pl.LightningModule, batch, batch_idx: int) -> torch.Tensor:
+        """
+        Perform a training step for the Multi-task BERT model.
+
+        Args:
+            batch: Input batch.
+            batch_idx (int): Index of the batch.
+
+        Returns:
+            torch.Tensor: Loss value
+        """
+        loss, ner_logits, intent_logits, ner_labels, intent_labels = self._common_step(batch, batch_idx)
+        accuracy_ner = self.accuracy(ner_logits, ner_labels, self.num_ner_labels)
+        accuracy_intent = self.accuracy(intent_logits, intent_labels, self.num_intent_labels)
+        self.log_dict({'training_loss': loss, 'ner_accuracy': accuracy_ner, 'intent_accuracy': accuracy_intent},
+                      on_step=False, on_epoch=True, prog_bar=True)
+        return loss
+
+    def on_validation_epoch_start(self):
+        self.validation_step_outputs_ner = []
+        self.validation_step_outputs_intent = []
+
+    def validation_step(self, batch, batch_idx: int) -> torch.Tensor:
+        """
+        Perform a validation step for the Multi-task BERT model.
+
+        Args:
+            batch: Input batch.
+            batch_idx (int): Index of the batch.
+
+        Returns:
+            torch.Tensor: Loss value.
+        """
+        loss, ner_logits, intent_logits, ner_labels, intent_labels = self._common_step(batch, batch_idx)
+        # self.log('val_loss', loss)
+        accuracy_ner = self.accuracy(ner_logits, ner_labels, self.num_ner_labels)
+        accuracy_intent = self.accuracy(intent_logits, intent_labels, self.num_intent_labels)
+        self.log_dict({'validation_loss': loss, 'val_ner_accuracy': accuracy_ner, 'val_intent_accuracy': accuracy_intent},
+                      on_step=False, on_epoch=True, prog_bar=True)
+
+        self.validation_step_outputs_ner.append(ner_logits)
+        self.validation_step_outputs_intent.append(intent_logits)
+        return loss
+
+    def on_validation_epoch_end(self):
+        """
+        Perform actions at the end of validation epoch to track the training process in WandB.
+        """
+        validation_step_outputs_ner = self.validation_step_outputs_ner
+        validation_step_outputs_intent = self.validation_step_outputs_intent
+
+        dummy_input = torch.zeros((1, 128), device=self.device, dtype=torch.long)
+        model_filename = f"model_{str(self.global_step).zfill(5)}.onnx"
+        torch.onnx.export(self, dummy_input, model_filename)
+        artifact = wandb.Artifact(name="model.ckpt", type="model")
+        artifact.add_file(model_filename)
+        self.logger.experiment.log_artifact(artifact)
+
+        flattened_logits_ner = torch.flatten(torch.cat(validation_step_outputs_ner))
+        flattened_logits_intent = torch.flatten(torch.cat(validation_step_outputs_intent))
+        self.logger.experiment.log(
+            {"valid/ner_logits": wandb.Histogram(flattened_logits_ner.to('cpu')),
+             "valid/intent_logits": wandb.Histogram(flattened_logits_intent.to('cpu')),
+             "global_step": self.global_step}
+        )
+
+    def _common_step(self, batch, batch_idx):
+        """
+        Common steps for both training and validation. Calculate loss for both NER and intent layer.
+
+        Returns:
+            Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+            Combiner loss value, NER logits, intent logits, NER labels, intent labels.
+        """
+        ids = batch['input_ids']
+        mask = batch['attention_mask']
+        ner_labels = batch['ner_labels']
+        intent_labels = batch['intent_labels']
+
+        ner_logits, intent_logits = self.forward(input_ids=ids, attention_mask=mask)
+
+        criterion = torch.nn.CrossEntropyLoss()
+
+        ner_loss = criterion(ner_logits.view(-1, self.num_ner_labels), ner_labels.view(-1).long())
+        intent_loss = criterion(intent_logits.view(-1, self.num_intent_labels), intent_labels.view(-1).long())
+
+        loss = ner_loss + intent_loss
+        return loss, ner_logits, intent_logits, ner_labels, intent_labels
+
+    def configure_optimizers(self):
+        optimizer = torch.optim.Adam(self.parameters(), lr=1e-5)
+        return optimizer

ner_labels.json

@@ -0,0 +1 @@
+{"O": 0, "B-DATE": 1, "I-DATE": 2, "B-TIME": 3, "I-TIME": 4, "B-TASK": 5, "I-TASK": 6, "B-DUR": 7, "I-DUR": 8}

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cbd376379912824c97a8c347e155db8e458526183f8939c2c6b2b780ea8698cc
+size 438053110

requirements.txt

@@ -0,0 +1,168 @@
+aiohttp==3.9.1
+aiosignal==1.3.1
+anyio==3.7.1
+appdirs==1.4.4
+argon2-cffi==21.3.0
+argon2-cffi-bindings==21.2.0
+arrow==1.2.3
+asttokens==2.2.1
+async-lru==2.0.4
+attrs==23.1.0
+Babel==2.12.1
+backcall==0.2.0
+beautifulsoup4==4.12.2
+bleach==6.0.0
+blinker==1.6.2
+certifi==2023.5.7
+cffi==1.15.1
+charset-normalizer==3.2.0
+click==8.1.7
+colorama==0.4.6
+coloredlogs==15.0.1
+comm==0.1.4
+contourpy==1.1.0
+cvxopt==1.3.2
+cvxpy==1.3.2
+cycler==0.11.0
+debugpy==1.6.7
+decorator==5.1.1
+defusedxml==0.7.1
+docker-pycreds==0.4.0
+ecos==2.0.12
+executing==1.2.0
+fastjsonschema==2.18.0
+filelock==3.12.4
+Flask==2.3.3
+flatbuffers==23.5.26
+fonttools==4.42.0
+fqdn==1.5.1
+frozenlist==1.4.1
+fsspec==2023.9.2
+gitdb==4.0.11
+GitPython==3.1.41
+huggingface-hub==0.17.2
+humanfriendly==10.0
+hypothesis==6.97.1
+idna==3.4
+iniconfig==2.0.0
+ipykernel==6.25.0
+ipython==8.14.0
+isoduration==20.11.0
+itsdangerous==2.1.2
+jedi==0.19.0
+Jinja2==3.1.2
+joblib==1.3.1
+json5==0.9.14
+jsonpointer==2.4
+jsonschema==4.18.6
+jsonschema-specifications==2023.7.1
+jupyter-events==0.7.0
+jupyter-lsp==2.2.0
+jupyter_client==8.3.0
+jupyter_core==5.3.1
+jupyter_server==2.7.0
+jupyter_server_terminals==0.4.4
+jupyterlab==4.0.4
+jupyterlab-pygments==0.2.2
+jupyterlab_server==2.24.0
+kiwisolver==1.4.4
+lightning==2.1.3
+lightning-utilities==0.10.1
+lxml==4.9.3
+MarkupSafe==2.1.3
+matplotlib==3.7.2
+matplotlib-inline==0.1.6
+mistune==3.0.1
+mpmath==1.3.0
+multidict==6.0.4
+nbclient==0.8.0
+nbconvert==7.7.3
+nbformat==5.9.2
+nest-asyncio==1.5.7
+networkx==3.2.1
+nnfs==0.5.1
+notebook_shim==0.2.3
+numpy==1.25.1
+onnx==1.15.0
+onnxruntime==1.17.0
+osqp==0.6.3
+overrides==7.4.0
+packaging==23.1
+pandas==2.0.3
+pandocfilters==1.5.0
+parso==0.8.3
+pickleshare==0.7.5
+Pillow==10.0.0
+platformdirs==3.10.0
+pluggy==1.4.0
+praw==7.7.1
+prawcore==2.4.0
+prometheus-client==0.17.1
+prompt-toolkit==3.0.39
+protobuf==4.25.2
+psutil==5.9.5
+pure-eval==0.2.2
+pyarrow==14.0.0
+pycparser==2.21
+pygame==2.5.0
+Pygments==2.16.1
+pyparsing==3.0.9
+PyPDF2==3.0.1
+pyreadline3==3.4.1
+pytest==8.0.0
+python-dateutil==2.8.2
+python-docx==1.1.0
+python-json-logger==2.0.7
+pytorch-lightning==2.1.3
+pytz==2023.3
+pywin32==306
+pywinpty==2.0.11
+PyYAML==6.0.1
+pyzmq==25.1.0
+qdldl==0.1.7.post0
+referencing==0.30.2
+regex==2023.8.8
+requests==2.31.0
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rpds-py==0.9.2
+safetensors==0.3.3
+scikit-learn==1.3.0
+scipy==1.11.1
+scs==3.2.3
+seaborn==0.12.2
+Send2Trash==1.8.2
+sentry-sdk==1.39.2
+setproctitle==1.3.3
+six==1.16.0
+smmap==5.0.1
+sniffio==1.3.0
+sortedcontainers==2.4.0
+soupsieve==2.4.1
+stack-data==0.6.2
+sympy==1.12
+terminado==0.17.1
+threadpoolctl==3.2.0
+tinycss2==1.2.1
+tokenizers==0.13.3
+torch==2.1.2
+torchaudio==2.1.2
+torchmetrics==1.3.0.post0
+torchvision==0.16.2
+tornado==6.3.2
+tqdm==4.66.1
+traitlets==5.9.0
+transformers==4.33.2
+typing_extensions==4.8.0
+tzdata==2023.3
+update-checker==0.18.0
+uri-template==1.3.0
+urllib3==2.0.4
+wandb==0.16.2
+wcwidth==0.2.6
+webcolors==1.13
+webencodings==0.5.1
+websocket-client==1.6.1
+Werkzeug==2.3.7
+windows-curses==2.3.1
+yarl==1.9.4

special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

tokenizer_config.json

@@ -0,0 +1 @@
+["tokenizer/tokenizer_config.json", "tokenizer/special_tokens_map.json", "tokenizer/vocab.txt", "tokenizer/added_tokens.json", "tokenizer/tokenizer.json"]

training_dataset.json

@@ -0,0 +1,177 @@
+[
+  {
+    "text": "Set a timer for 10 minutes.",
+    "intent": "'Set Timer'",
+    "entities": "O O O O B-DUR I-DUR"
+  },
+  {
+    "text": "Remind me about the meeting at 3 PM tomorrow.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O O O B-TIME I-TIME B-DATE"
+  },
+  {
+    "text": "Schedule an appointment for next Friday at 9 AM.",
+    "intent": "'Schedule Appointment'",
+    "entities": "O O O O B-DATE I-DATE O B-TIME I-TIME"
+  },
+  {
+    "text": "Can you set a reminder for my doctor's appointment on Monday?",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O O O O O O O B-DATE"
+  },
+  {
+    "text": "I want to schedule a meeting for the 15th of this month at 2:30 PM.",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O O O O O O O B-DATE I-DATE I-DATE I-DATE O B-TIME I-TIME I-TIME I-TIME"
+  },
+  {
+    "text": "Set an alarm for 7 AM.",
+    "intent": "'Set Alarm'",
+    "entities": "O O O O B-TIME I-TIME"
+  },
+  {
+    "text": "Remind me to call John in 30 minutes.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O B-TASK I-TASK O B-DUR I-DUR"
+  },
+  {
+    "text": "\"Schedule a meeting for next Wednesday afternoon.\"",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O O O B-DATE I-DATE B-TIME"
+  },
+  {
+    "text": "Can you set a timer for cooking for 1 hour?",
+    "intent": "'Set Timer'",
+    "entities": "O O O O O O B-TASK O B-DUR I-DUR"
+  },
+  {
+    "text": "Remind me about the project deadline at 5 PM on Friday.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O B-TASK I-TASK O B-TIME I-TIME O B-DATE"
+  },
+  {
+    "text": "Schedule a doctor's appointment for March 20th at 10:30 AM.",
+    "intent": "'Schedule Appointment'",
+    "entities": "O O O O O B-DATE I-DATE O B-TIME I-TIME I-TIME I-TIME"
+  },
+  {
+    "text": "Set a timer for a 15-minute break.",
+    "intent": "'Set Timer'",
+    "entities": "O O O O O B-DUR I-DUR I-DUR B-TASK"
+  },
+  {
+    "text": "Remind me to buy groceries tomorrow morning.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O B-TASK I-TASK B-DATE B-TIME"
+  },
+  {
+    "text": "Schedule a conference call for the first Monday of next month at 3 PM.",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O O O O O B-DATE I-DATE I-DATE I-DATE I-DATE O B-TIME I-TIME"
+  },
+  {
+    "text": "Can you remind me to send the report at 4:30 PM today?",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O O B-TASK I-TASK I-TASK O B-TIME I-TIME I-TIME I-TIME B-DATE"
+  },
+  {
+    "text": "Set a timer for a 20-minute workout session.",
+    "intent": "'Set Timer'",
+    "entities": "O O O O O B-DUR I-DUR I-DUR B-TASK I-TASK"
+  },
+  {
+    "text": "Remind me to water the plants every Tuesday and Thursday at 9 AM.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O B-TASK I-TASK I-TASK O B-DATE O B-DATE O B-TIME I-TIME"
+  },
+  {
+    "text": "Schedule a team meeting for next Monday morning at 10:30.",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O O O O B-DATE I-DATE B-TIME I-TIME I-TIME I-TIME I-TIME"
+  },
+  {
+    "text": "Can you set an alarm for 6:45 AM?",
+    "intent": "'Set Alarm'",
+    "entities": "O O O O O O B-TIME I-TIME I-TIME I-TIME"
+  },
+  {
+    "text": "Remind me about the webinar in 2 days at 2 PM.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O B-TASK O B-DUR I-DUR O B-TIME I-TIME"
+  },
+  {
+    "text": "Schedule a dentist appointment for April 5th at 11:00 in the morning.",
+    "intent": "'Schedule Appointment'",
+    "entities": "O O B-TASK I-TASK O B-DATE I-DATE O B-TIME I-TIME I-TIME I-TIME I-TIME I-TIME"
+  },
+  {
+    "text": "Set a timer for a 5-minute meditation session.",
+    "intent": "'Set Timer'",
+    "entities": "O O O O O B-DUR I-DUR I-DUR B-TASK I-TASK"
+  },
+  {
+    "text": "Remind me to call Sarah next Wednesday afternoon.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O B-TASK I-TASK B-DATE I-DATE B-TIME"
+  },
+  {
+    "text": "Schedule a review meeting for the end of the month at 4:30 PM.",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O B-TASK I-TASK O O B-DATE I-DATE I-DATE I-DATE O B-TIME I-TIME I-TIME I-TIME"
+  },
+  {
+    "text": "Can you remind me to pay bills on the last day of the month?",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O O B-TASK I-TASK O O B-DATE I-DATE I-DATE I-DATE I-DATE"
+  },
+  {
+    "text": "Set a timer for 45 minutes for a study session.",
+    "intent": "'Set Timer'",
+    "entities": "O O O O B-DUR I-DUR O O B-TASK I-TASK"
+  },
+  {
+    "text": "Remind me to pick up the laundry every Friday afternoon.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O B-TASK I-TASK I-TASK I-TASK O B-DATE B-TIME"
+  },
+  {
+    "text": "Schedule a client meeting for the 10th of next month at 2 PM.",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O B-TASK I-TASK O O B-DATE I-DATE I-DATE I-DATE O B-TIME I-TIME"
+  },
+  {
+    "text": "Can you set an alarm for 7:30 AM tomorrow?",
+    "intent": "'Set Alarm'",
+    "entities": "O O O O O O B-TIME I-TIME I-TIME I-TIME B-DATE"
+  },
+  {
+    "text": "Remind me about the presentation at 4 PM today.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O B-TASK O B-TIME I-TIME B-DATE"
+  },
+  {
+    "text": "Schedule a doctor's appointment for May 15th in the evening.",
+    "intent": "'Schedule Appointment'",
+    "entities": "O O B-TASK I-TASK O B-DATE I-DATE O O B-TIME"
+  },
+  {
+    "text": "Set a timer for a 10-minute break between study sessions.",
+    "intent": "'Set Timer'",
+    "entities": "O O O O O B-DUR I-DUR I-DUR O O O O"
+  },
+  {
+    "text": "Remind me to send the report at 9 AM tomorrow.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O B-TASK I-TASK I-TASK O B-TIME I-TIME B-DATE"
+  },
+  {
+    "text": "Schedule a team lunch for next Friday at noon.",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O B-TASK I-TASK O B-DATE I-DATE O B-TIME"
+  },
+  {
+    "text": "Can you remind me to buy groceries on Saturday afternoon?",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O O B-TASK I-TASK O B-DATE B-TIME"
+  }
+]

utils.py

@@ -0,0 +1,88 @@
+from transformers import BertTokenizerFast, BertConfig
+from typing import Dict, List, Union, Tuple
+
+
+def num_unique_labels(dataset: Dict[str, Union[str, List[str]]]) -> Tuple[int, int]:
+    """
+    Calculate the number of NER labels and INTENT labels in the dataset.
+
+    Args:
+        dataset (dict): A dictionary containing 'text', 'entities' and 'intent' keys.
+
+    Returns:
+        Tuple: Number of unique NER and INTENT lables.
+    """
+    one_dimensional_ner = [tag for subset in dataset['entities'] for tag in subset]
+    return len(set(one_dimensional_ner)), len(set(dataset['intent']))
+
+def ner_labels_to_ids() -> Dict[str, int]:
+    """
+    Map NER labels to corresponding numeric IDs.
+
+    Returns:
+        Dict[str, int]: A dictionary where keys are NER labels, and values are their corresponding IDs.
+    """
+    labels_to_ids_ner = {
+    'O': 0,
+    'B-DATE': 1,
+    'I-DATE': 2,
+    'B-TIME': 3,
+    'I-TIME': 4,
+    'B-TASK': 5,
+    'I-TASK': 6,
+    'B-DUR': 7,
+    'I-DUR': 8
+    }
+    return labels_to_ids_ner
+
+def ner_ids_to_labels(ner_labels_to_ids) -> Dict[int, str]:
+    """
+    Map numeric IDs to corresponding NER labels.
+
+    Returns:
+        Dict[int, str]: A dictionary where keys are numeric IDs, and values are their corresponding NER labels.
+    """
+    ner_ids_to_labels = {v: k for k, v in ner_labels_to_ids.items()}
+    return ner_ids_to_labels
+
+def intent_labels_to_ids() -> Dict[str, int]:
+    """
+    Map intent labels to corresponding numeric values.
+
+    Returns:
+        Dict[str, int]: A dictionary where keys are intent labels, and values are their corresponding numeric IDs.
+    """
+    intent_labels_to_ids = {
+    "'Schedule Appointment'": 0,
+    "'Schedule Meeting'": 1,
+    "'Set Alarm'": 2,
+    "'Set Reminder'": 3,
+    "'Set Timer'": 4
+    }
+    return intent_labels_to_ids
+
+def intent_ids_to_labels(intent_labels_to_ids) -> Dict[int, str]:
+    """
+    Map numeric values to corresponding intent labels.
+
+    Returns:
+        Dict[int, str]: A dictionary where keys are numeric IDs, and values are their corresponding intent labels.
+    """
+    intent_ids_to_labels = {v: k for k, v in intent_labels_to_ids.items()}
+    return intent_ids_to_labels
+
+def tokenizer() -> BertTokenizerFast:
+    tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')
+    return tokenizer
+
+def bert_config() -> BertConfig:
+    config = BertConfig.from_pretrained('bert-base-uncased')
+    return config
+
+def structure_data(dataset):
+    structured_data = {'text': [], 'entities': [], 'intent': []}
+    for sample in dataset:
+        structured_data['text'].append(sample['text'])
+        structured_data['entities'].append(sample['entities'].split())
+        structured_data['intent'].append(sample['intent'])
+    return structured_data

validation_dataset.json

@@ -0,0 +1,122 @@
+[
+  {
+    "text": "Set a reminder for my dentist appointment next Tuesday at 9 AM.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O O B-TASK I-TASK B-DATE I-DATE O B-TIME I-TIME"
+  },
+  {
+    "text": "Can you schedule a meeting for Friday afternoon?",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O O O O O B-DATE B-TIME"
+  },
+  {
+    "text": "Set an alarm for 7:30 AM to wake up.",
+    "intent": "'Set Alarm'",
+    "entities": "O O O O B-TIME I-TIME I-TIME O O O"
+  },
+  {
+    "text": "Remind me about the call with the client in 2 hours.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O B-TASK I-TASK I-TASK I-TASK O B-TIME I-TIME"
+  },
+  {
+    "text": "Schedule a doctor's appointment for May 10th at 11:45 AM.",
+    "intent": "'Schedule Appointment'",
+    "entities": "O O B-TASK I-TASK O B-DATE I-DATE O B-TIME I-TIME I-TIME I-TIME"
+  },
+  {
+    "text": "Schedule a conference call for next Monday morning at 9:00 sharp.",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O B-TASK I-TASK O B-DATE I-DATE B-TIME I-TIME I-TIME I-TIME I-TIME O"
+  },
+  {
+    "text": "Set a timer for a 5-minute break between study sessions.",
+    "intent": "'Set Timer'",
+    "entities": "O O O O O B-DUR I-DUR I-DUR O O O O"
+  },
+  {
+    "text": "Remind me to water the plants every Sunday and Wednesday at 7 AM.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O B-TASK I-TASK I-TASK B-DATE I-DATE O B-DATE O B-TIME I-TIME"
+  },
+  {
+    "text": "Can you schedule a dentist appointment for next month?",
+    "intent": "'Schedule Appointment'",
+    "entities": "O O O O B-TASK I-TASK O B-DATE I-DATE"
+  },
+  {
+    "text": "Set an alarm for 4:30 PM to walk the dog.",
+    "intent": "'Set Alarm'",
+    "entities": "O O O O B-TIME I-TIME I-TIME I-TIME O B-TASK I-TASK I-TASK"
+  },
+  {
+    "text": "Set a timer for 20 minutes while I meditate.",
+    "intent": "'Set Timer'",
+    "entities": "O O O O B-DUR I-DUR O O O"
+  },
+  {
+    "text": "Remind me to pick up dry cleaning this Thursday after work.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O B-TASK I-TASK I-TASK I-TASK O B-DATE O O"
+  },
+  {
+    "text": "Schedule a team lunch for next Wednesday at noon.",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O B-TASK I-TASK O B-DATE I-DATE O B-TIME"
+  },
+  {
+    "text": "Can you set an alarm for 8:15 AM tomorrow?",
+    "intent": "'Set Alarm'",
+    "entities": "O O O O O O B-TIME I-TIME I-TIME I-TIME B-DATE"
+  },
+  {
+    "text": "Remind me about the doctor's appointment on the 25th at 10:30 AM.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O B-TASK I-TASK O O B-DATE O B-TIME I-TIME I-TIME I-TIME"
+  },
+  {
+    "text": "Remind me to submit the report by next Monday at 5 PM.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O B-TASK I-TASK I-TASK O B-DATE I-DATE O B-TIME I-TIME"
+  },
+  {
+    "text": "Set a timer for 45 minutes for a cooking session.",
+    "intent": "'Set Timer'",
+    "entities": "O O O O B-DUR I-DUR O O B-TASK I-TASK"
+  },
+  {
+    "text": "Schedule a client meeting for the 10th of next month at 2:30 PM.",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O B-TASK I-TASK O O B-DATE I-DATE I-DATE I-DATE O B-TIME I-TIME I-TIME I-TIME"
+  },
+  {
+    "text": "Can you set an alarm for 9 AM every weekday?",
+    "intent": "'Set Alarm'",
+    "entities": "O O O O O O B-TIME I-TIME O B-DATE"
+  },
+  {
+    "text": "Remind me about the appointment with the lawyer on April 15th at 11 AM.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O O B-TASK I-TASK I-TASK I-TASK O B-DATE I-DATE O B-TIME I-TIME"
+  },
+  {
+    "text": "Schedule a study group session for next Friday evening at 6:30 PM.",
+    "intent": "'Schedule Meeting'",
+    "entities": "O O B-TASK I-TASK I-TASK O B-DATE I-DATE O O B-TIME I-TIME I-TIME I-TIME"
+  },
+  {
+    "text": "Set a timer for a 10-minute power nap.",
+    "intent": "'Set Timer'",
+    "entities": "O O O O O B-DUR I-DUR I-DUR O O"
+  },
+  {
+    "text": "Remind me to buy tickets for the concert on Thursday at noon.",
+    "intent": "'Set Reminder'",
+    "entities": "O O O B-TASK I-TASK O O O O B-DATE O B-TIME"
+  },
+  {
+    "text": "Set an alarm for 7:45 AM to start morning exercises.",
+    "intent": "'Set Alarm'",
+    "entities": "O O O O B-TIME I-TIME I-TIME I-TIME O O O O"
+  }
+]