Content Comparison

Getting Started

...

go to main.py

Image Removed

Ontology

What is an Ontology?

For general information please check out: Preliminaries and Quiz Materials.

For this project:

1. Intents represent the user's high-level actions or goals.

   • Example: When a user says, "Can you recommend a recipe?", the intent could be requestRecommendation.

2. Slots define specific pieces of information extracted from the user’s input.

   • Example: In the query "Add garlic and chicken thighs to the recipe filter," garlic and chicken thighs are slot values of the ingredient slot type.

The ontology file is where all the possible intents and slots for the system are defined.

Steps to Analyze the Ontology

1. Open the Ontology File

   • Locate the ontology file (ontology.json) in your project. This file contains two key sections:

     • Intents: A list of all possible intents your system can predict.

     • Slots: A dictionary where the keys represent slot types (e.g., ingredient) and the values are lists of possible slot values (e.g., garlic, chicken thighs).

2. Review the Intents

   • Look at the intents section in the file. Each intent represents a unique user goal or action.

   • Reflect on the variety of intents. For example:

     • What do intents like greeting or farewell imply about the system's capabilities?

     • How does the system distinguish between recipeRequest and requestRecommendation?

3. Explore the Slots

   • Examine the slots section. This is a dictionary of slot types and their potential values.

   • Key questions to consider:

     • How many slot types are defined? Examples might include ingredient, cuisine, or recipe.

     • Are there any patterns in the slot values?

     • How do these slots connect to our MARBEL agent potentially?

4. Think About Model Outputs

   • Your model will predict one intent per input (intent classification) and assign a slot label to each token in the input (slot filling).

   • Understanding the ontology helps you map these predictions to actionable output

Fitting Encoders

What Are Encoders?

Encoders translate text-based labels (like intents and slot types) into numerical values that the model can work with. This process standardizes the inputs and outputs, ensuring consistency across training, evaluation, and inference.

1. Intent Label Encoder:

   • Maps each intent from the ontology (e.g., recipeRequest, greeting) to a unique number.

   • Used for intent classification.

2. Slot Label Encoder:

   • Converts slot types and their corresponding BIO-format tags (B-slot, I-slot, O) into numbers.

   • Used for slot filling at the token level.

Steps in the Encoding Process

Take a close look at the fit_encoders function in dataset.py. It performs the following steps:

...

Load the Ontology:

• The function reads the ontology file to extract the list of intents and slot types:

...

Fit the Intent Label Encoder:

• The intent encoder assigns a unique numerical label to each intent in the ontology:

  intent_label_encoder.fit(intents)

• Key Insight: This step ensures that intent classification produces outputs in a consistent format.

Generate BIO Tags for Slots:

...

Slot tags are converted into BIO format:

• B-{slot}: Beginning of a slot entity.

• I-{slot}: Inside a slot entity.

• O: Outside of any slot entity.

All slot tags are compiled into a single list:

all_slot_tags = ['O'] + [f'B-{slot}' for slot in slots.keys()]
                   + [f'I-{slot}' for slot in slots.keys()]

...

These tags are then fitted to the slot encoder:

...

Why BIO Format?: This labeling scheme helps identify the boundaries of multi-token slot entities.

• Think about why this could be important in our context and what slots could specifically benefit.

Dataset

Preproccessing Distribution Dataset

Train

Evaluate

...

Image Added

Natural Language Understanding (NLU) is a core component of conversational AI systems, enabling machines to interpret and act on user input in natural language. This Intent and Slot Classifier project is designed to help students understand the pipeline involved in building an NLU model that performs intent classification and slot filling. These tasks allow AI models to classify a user's goal (intent) and extract key information (slots) from their input.

For instance, given the input:
"Find me a Japanese recipe for lunch,"
the model would classify the intent as "find_recipe" and extract slots like "cuisine: Japanese" and "mealType: lunch".

This project uses BERT, a state-of-the-art transformer-based language model, to perform these tasks effectively. The system provides end-to-end functionality for training, evaluating, and running inference on the classifier.

...

Purpose of the Project

The primary goals of this project are:

1. To demonstrate the application of transformers for intent classification and slot filling.

2. To provide students with hands-on experience in creating and working with NLU pipelines.

3. To showcase best practices for preparing datasets, building models, and evaluating their performance.

To complete these goals you must go through all subpages in this section starting with Ontology.

...

Repository Overview

The repository is structured as follows:
utils/
├── checkpoints/          # Directory for saving trained model checkpoints
├── data/                 # Directory containing data files (ontology, train/test datasets)
│   ├── ontology.json     # Ontology file containing intents, slots, and synonyms
│   ├── train.json        # Training dataset
│   ├── test.json         # Test dataset
│   └── synonyms.json     # Synonyms for slot normalization
├── data_processing.py    # Utilities for additional data preprocessing (if needed)
├── dataset.py            # Dataset preparation and preprocessing module
├── evaluation.py         # Model evaluation and metrics generation
├── run_train_test.py     # Main script to run training, evaluation, and inference
├── model.py              # Defines the BERT-based model architecture
├── predict.py            # Inference module for predicting intents and slots
├── requirements.txt      # Python dependencies for the project
├── train.py              # Training module for the intent-slot classifier
└── utils.py              # Helper functions for argument parsing, slot normalization, and synonym resolution

...

Explanation of Key Modules

run_train_test.py

This is the central script for orchestrating the intent and slot classifier independently. It integrates data preparation, training, evaluation, and inference, all controlled via command-line arguments.

dataset.py

This module handles data loading, preprocessing, and BIO tagging. It uses the NLURecipeDataset class for creating PyTorch-compatible datasets.

model.py

Defines the BERTNLUModel, a BERT-based architecture with separate heads for intent classification and slot filling.

train.py

Implements the training routine, including optimization and backpropagation.

evaluation.py

Provides functionality to evaluate the model’s performance, generating accuracy scores and classification reports.

predict.py

Handles inference by predicting intents and slot tags for new inputs. It includes functions for extracting and normalizing slots using the ontology.

utils.py

Contains helper functions for:

• Parsing command-line arguments.

• Loading and normalizing synonyms.

• Extracting and formatting slot values from predictions.

...

Arguments

The utils.py module defines the command-line arguments. Here’s a summary:

...

Use

1. Viewing Dataset Distribution

To analyze the distribution of intents and slots in the dataset:

python run_train_test.py --show_dist 

2. Training the Model

To train the model using the training dataset:

python run_train_test.py --train_model

3. Evaluating the Model

To evaluate a pre-trained model on the test dataset:

python run_train_test.py --evaluate 

4. Running Inference

To predict the intent and slots for a given input text:

python run_train_test.py --inference_text "Find me a Japanese recipe for lunch."

5. Run with ASR

When complete with this section read https://socialrobotics.atlassian.net/wiki/spaces/PCA2/pages/2709488567/Run+your+Conversational+Agent#Run-your-Intent-and-Slot-Classifier-with-WHISPER to connect your intent and slot classifier with WHISPER