MLOps Blog

Best Tools For NLP Projects That Every Data Scientist and ML Engineer Should Try

Kurtis Pykes

12 min

21st August, 2023

Machine Learning Tools Natural Language Processing

Natural Language Processing (NLP) is an extremely important subset of Artificial Intelligence. There is major adoption of NLP in enterprise, driven by factors like the increase of smart device usage (also known as human-to-machine communication), advances in healthcare with NLP, and the adoption of cloud-based solutions. But what exactly is NLP, and why is it important?

NLP is at the intersection of Linguistics, Computer Science, and Artificial Intelligence. Applications of NLP process and analyze large amounts of natural language data – all languages spoken by humans are natural languages, whether that language is English, French, or Mandarin – in order to imitate interactions between humans, in a human-like way. A good NLP system can understand the contents of documents, including the nuances in them.

Why is NLP so important?

We’re more dependent on machines than ever, very much thanks to their ability to be more accurate than us, and permit us to be much more efficient. They don’t get tired. They don’t complain. They never get bored. However, with NLP tasks, there’s a major obstacle…

For humans, mastering a language is relatively simple, but for machines to master natural language is a big challenge. The creativity of natural language, and the ambiguity of languages, makes NLP a demanding area to work in. Solving a problem means that for our problem, we come up with a solution that resolves the issues of language creativity and ambiguity – therefore, we add structure to data that is considered unstructured (i.e. text doesn’t have a schema, unlike a record of transaction history at a store).

Different types of NLP tasks

There are a lot of different tasks that NLP can perform, but there’s a set of fundamental tasks that tend to recur frequently across various NLP projects. As a result of their repetitive nature, these tasks have been studied much more in-depth than other NLP tasks. These fundamental NLP tasks are:

Language modelling

Language Modelling (LM) is assigning a probability to any sequence of words. Essentially, in a language modelling task, we try to predict the next word that occurs in a sequence, given the history of words that occurred before. LM is vital in various applications of NLP, and is the reason why machines can understand qualitative information. Some applications of Language Modelling include: speech recognition, optical character recognition, handwriting recognition, machine translation, and spelling correction.

Text classification

Text classification assigns predefined categories to text based on its content. By far, text classification is the most popular application of NLP, used to build various tools such as spam detectors and sentiment analysis bots.

Information extraction

Information Extraction (IE) is automatically extracting relevant information from unstructured and/or semi-structured text documents. Examples of these types of documents include calendar events from emails, or the names of people mentioned in a post on social media.

Information retrieval

Everyone online interacts with some sort of Information Retrieval (IR) system – Google search, for example. IR is the task of finding relevant documents from a large collection of documents with respect to a query made by a user.

Conversational agent

Conversational Agents fall under Conversational AI. Conversational AI involves building dialogue systems that imitate human interactions in terms of conversation. Popular examples of Conversational AI include Alexa, Siri, Google Home, and Cortana for Windows lovers. Technologies such as chatbots are also powered by conversational agents, and growing in popularity in enterprise companies.

Text summarization

Automatic summarization is the process of shortening a set of data computationally, to create a subset that represents the most important or relevant information within the original content [Source: Wikipedia].

Question answering

Question Answering is the task of building systems that can automate answers to questions posed by humans in natural language.

Machine translation

Machine Translation (MT) is a subfield of computational linguistics concerned with converting a piece of text from one language to another. A popular application of this type is Google Translate.

Topic modelling

Topic modelling is an Unsupervised Machine Learning technique that uncovers the topical structure of a large collection of documents. This application of NLP is quite a common tool, used across a variety of domains – like Literature, and Bioinformatics.

While each of these tasks is quite different, establishing a firm grip on these tasks is enough to equip any aspiring NLP practitioner with a good foundation to build a variety of NLP applications. Part of mastering these applications involves learning the technologies you can use to increase your productivity when working on problems.

Tools for NLP projects

There are a variety of open-source tools for finding valuable insights in unstructured text (or other forms of natural language), and solving a variety of problems. The list of frameworks provided below is by no means exhaustive, but they’re a great start to make Natural Language Processing accessible to businesses or anyone that wishes to use NLP in their projects. Without further ado, here’s the list of frameworks used most often for Natural Language Processing (NLP) projects.

NLTK

Natural Language ToolKit (NLTK) is one of the leading platforms for building Python programs to process and analyze human language data. The NLTK documentation states that ‘It provides easy-to-use interfaces to over 50 corpora and lexical resources such as WordNet, along with a suite of text processing libraries for classification, tokenization, stemming, tagging, parsing, and semantic reasoning, wrappers for industrial-strength NLP libraries, and an active discussion forum.’

Like most things in the programming world, mastering NLTK takes some time. Luckily, there are lots of resources out there to aid you in your hopes of mastering the framework, like the book Natural Language Processing with Python, written by the creators of NLTK themselves – it takes a very practical approach to programming for Natural Language Processing tasks.

An example of some tasks you could perform with NLTK include tokenization, tagging, stemming, lemmatization, parsing, classification, and many more. Take a look at the code snippet below from the NLTK Documentation.

# Example of Tokenization
import nltk

sentence = """At eight o'clock on Thursday morning Arthur didn't feel very good."""
tokens = nltk.word_tokenize(sentence)
print(tokens)

>>>> ['At', 'eight', "o'clock", 'on', 'Thursday', 'morning', 'Arthur', 'did', "n't", 'feel', 'very', 'good', '.']

# Example of tagging tokens
tagged = nltk.pos_tag(tokens)
print(tagged[0:6])

>>>> [('At', 'IN'), ('eight', 'CD'), ("o'clock", 'JJ'), ('on', 'IN'),
('Thursday', 'NNP'), ('morning', 'NN')]

# Example of identifying named entities
entities = nltk.chunk.ne_chunk(tagged)
print(entities)

>>>> Tree('S', [('At', 'IN'), ('eight', 'CD'), ("o'clock", 'JJ'),
           ('on', 'IN'), ('Thursday', 'NNP'), ('morning', 'NN'),
       Tree('PERSON', [('Arthur', 'NNP')]),
           ('did', 'VBD'), ("n't", 'RB'), ('feel', 'VB'),
           ('very', 'RB'), ('good', 'JJ'), ('.', '.')])

# Displaying a parse tree
from nltk.corpus import treebank

t = treebank.parsed_sents('wsj_0001.mrg')[0]
t.draw()

NLP tools - NLTK — ***Source:*** **NLTK Documentation**

SpaCy

SpaCy’s initial release was in February 2015, making it one of the more recent open-source frameworks for Python Natural Language Processing applications. Compared to NLTK, which was created in 2001, SpaCy creators had enough time to learn NLTK and see where it’s lacking. One of the most recognizable improvements in comparison to NTLK includes performance enhancements, since SpaCy uses some of the latest and best algorithms.

In addition, SpaCy is very well documented and has been designed to support large volumes of data. It also consists of a flurry of pretrained Natural Language Processing models, which makes learning, teaching, and doing Natural Language Processing with SpaCy more accessible.

Note: If you wish to apply Deep Learning algorithms to your unstructured data, SpaCy is probably the library to work with – the same goes for extraction tasks.

Below is an example of SpaCy’s capabilities from the SpaCy documentation.

import spacy

# Load English tokenizer, tagger, parser and NER
nlp = spacy.load("en_core_web_sm")

# Process whole documents
text = ("When Sebastian Thrun started working on self-driving cars at Google in 2007, few people outside of the company took him seriously.
I can tell you very senior CEOs of major American car companies would
shake my hand and turn away because 'I wasn't worth talking to',
said Thrun, in an interview with Recode earlier this week.")
doc = nlp(text)

# Analyze syntax
print("Noun phrases:", [chunk.text for chunk in doc.noun_chunks])
print("Verbs:", [token.lemma_ for token in doc if token.pos_ == "VERB"])

# Find named entities, phrases and concepts
for entity in doc.ents:
    print(entity.text, entity.label_)

>>>> Noun phrases: ['Sebastian Thrun', 'self-driving cars', 'Google', 'few people', 'the company', 'him', 'I', 'you', 'very senior CEOs', 'major American car companies', 'my hand', 'I', 'Thrun', 'an interview', 'Recode']
Verbs: ['start', 'work', 'drive', 'take', 'can', 'tell', 'would', 'shake', 'turn', 'talk', 'say']
Sebastian NORP
Google ORG
2007 DATE
American NORP
Recode ORG
earlier this week DATE

Stanford CoreNLP

CoreNLP is an extremely popular library for Natural Language Processing tasks, built by the Stanford NLP community – they also actively maintain the framework. On the contrary to NLTK and SpaCy, which were written in either Python or Cython respectively, CoreNLP is in Java – meaning that your computer will need to have JDK (but it does have APIs for most programming languages).

On the CoreNLP homepage, the developers describe CoreNLP as “your one stop shop for natural language processing in Java! CoreNLP enables users to derive linguistic annotations for text, including token and sentence boundaries, parts of speech, named entities, numeric and time values, dependency and constituency parser, coreference, sentiment, quote attributions, and relations. CoreNLP currently supports 6 languages: Arabic, Chinese, English, French, German, and Spanish.”

One of the main advantages of CoreNLP is that it’s very scalable, which makes it a go-to choice for complex tasks. Another factor is that it was built with speed in mind – it’s been optimized to be extremely fast.

Gensim

Gensim is a specialized open-source Python framework that, used to represent documents as semantic vectors in the most efficient and painless ways possible. The authors designed Gensim to process raw, unstructured plain text using a variety of Machine Learning algorithms – so using Gensim to approach tasks like Topic Modelling is a good idea. Plus, Gensim does a good job at identifying similarities in text, indexing text, and navigating different documents.

In the documentation, the authors explicitly state that Gensim was built from scratch for 3 reasons:

Practicality – as industry experts, we focus on proven, battle-hardened algorithms to solve real industry problems. More focus on engineering, less on academia.
Memory independence – there’s no need for the whole training corpus to reside fully in RAM at any one time. It can process large, web-scale corpora using data streaming.
Performance – highly optimized implementations of popular vector space algorithms using C, BLAS and memory-mapping.

Below are some code examples from Gensim Word2Vec tutorial on their documentation page.

import gensim.downloader as api
wv = api.load('word2vec-google-news-300')

for index, word in enumerate(wv.index2entity):
    if index == 10:
        break
    print(f"word #{index}/{len(wv.index2entity)} is {word}")

>>>> word #0/3000000 is </s> 
     word #1/3000000 is in
     word #2/3000000 is for
     word #3/3000000 is that 
     word #4/3000000 is is 
     word #5/3000000 is on
     word #6/3000000 is ##
     word #7/3000000 is The
     word #8/3000000 is with 
     word #9/3000000 is said

pairs = [
    ('car', 'minivan'),   # a minivan is a kind of car
    ('car', 'bicycle'),   # still a wheeled vehicle
    ('car', 'airplane'),  # ok, no wheels, but still a vehicle
    ('car', 'cereal'),    # ... and so on
    ('car', 'communism'),
]
for w1, w2 in pairs:
    print('%rt%rt%.2f' % (w1, w2, wv.similarity(w1, w2)))

>>>> ‘car’    ‘minivan’    0.69
     ‘car’    ‘bicycle’    0.54
     ‘car’    ‘airplane’   0.42
     ‘car’    ‘cereal’     0.14
     ‘car’    ‘communism’  0.06

TensorFlow & PyTorch

Despite being 2 very different frameworks, I thought it best to list the 2 frameworks because they’re both regarded as popular frameworks for Deep Learning. Tensorflow is the older one, and it was developed by Google’s Brain team – who also actively use the framework for research and production-level projects. On the other hand, Pytorch is an open-source library that was based on the Torch library, and primarily developed by Facebook’s AI Research (FAIR) lab.

The Tensorflow or PyTorch debate runs deep, and it’s definitely beyond the scope of this article. My advice for anybody unsure of which one to learn would be to learn the one your organization uses, or the organization you want to work for. If they haven’t quite adopted deep learning, then I’d say PyTorch has an easier learning curve.

Below you can see how to build an LSTM model using both frameworks. First up is Tensorflow – for the full code source, visit Christian Versloot Machine Curve Blog.

# Code Source - Christian Versloot Machine Curve Blog
import tensorflow as tf
from tensorflow.keras.datasets import imdb
from tensorflow.keras.layers import Embedding, Dense, LSTM
from tensorflow.keras.losses import BinaryCrossentropy
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Model configuration
additional_metrics = ['accuracy']
batch_size = 128
embedding_output_dims = 15
loss_function = BinaryCrossentropy()
max_sequence_length = 300
num_distinct_words = 5000
number_of_epochs = 5
optimizer = Adam()
validation_split = 0.20
verbosity_mode = 1

# Disable eager execution
tf.compat.v1.disable_eager_execution()

# Load dataset
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=num_distinct_words)
print(x_train.shape)
print(x_test.shape)

# Pad all sequences
padded_inputs = pad_sequences(x_train, maxlen=max_sequence_length, value = 0.0) # 0.0 because it corresponds with <PAD>
padded_inputs_test = pad_sequences(x_test, maxlen=max_sequence_length, value = 0.0) # 0.0 because it corresponds with <PAD>

# Define the Keras model
model = Sequential()
model.add(Embedding(num_distinct_words, embedding_output_dims, input_length=max_sequence_length))
model.add(LSTM(10))
model.add(Dense(1, activation='sigmoid'))

# Compile the model
model.compile(optimizer=optimizer, loss=loss_function, metrics=additional_metrics)

# Give a summary
model.summary()

# Train the model
history = model.fit(padded_inputs, y_train, batch_size=batch_size, epochs=number_of_epochs, verbose=verbosity_mode, validation_split=validation_split)

# Test the model after training
test_results = model.evaluate(padded_inputs_test, y_test, verbose=False)
print(f'Test results - Loss: {test_results[0]} - Accuracy: {100*test_results[1]}%')

>>>> Test results - Loss: 0.3655 - Accuracy: 85.6880

And here is an LSTM in PyTorch – for a full run through and the source code, visit Sequence Model Tutorials in the PyTorch Documentation.

# Source Code from Sequence Model Tutorials in PyTorch Documentation 
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

torch.manual_seed(1)

# Data preparation
def prepare_sequence(seq, to_ix):
    idxs = [to_ix[w] for w in seq]
    return torch.tensor(idxs, dtype=torch.long)
training_data = [
    # Tags are: DET - determiner; NN - noun; V - verb
    # For example, the word "The" is a determiner
    ("The dog ate the apple".split(), ["DET", "NN", "V", "DET", "NN"]),
    ("Everybody read that book".split(), ["NN", "V", "DET", "NN"])
]
word_to_ix = {}
# For each words-list (sentence) and tags-list in each tuple of training_data
for sent, tags in training_data:
    for word in sent:
        if word not in word_to_ix:  # word has not been assigned an index yet
            word_to_ix[word] = len(word_to_ix)  # Assign each word with a unique 
tag_to_ix = {"DET": 0, "NN": 1, "V": 2}  # Assign each tag with a unique index

# These will usually be more like 32 or 64 dimensional.
# We will keep them small, so we can see how the weights change as we train.
EMBEDDING_DIM = 6
HIDDEN_DIM = 6

# creating the model
class LSTMTagger(nn.Module):

    def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):
        super(LSTMTagger, self).__init__()
        self.hidden_dim = hidden_dim

        self.word_embeddings = nn.Embedding(vocab_size, embedding_dim)

        # The LSTM takes word embeddings as inputs, and outputs hidden states
        # with dimensionality hidden_dim.
        self.lstm = nn.LSTM(embedding_dim, hidden_dim)

        # The linear layer that maps from hidden state space to tag space
        self.hidden2tag = nn.Linear(hidden_dim, tagset_size)

    def forward(self, sentence):
        embeds = self.word_embeddings(sentence)
        lstm_out, _ = self.lstm(embeds.view(len(sentence), 1, -1))
        tag_space = self.hidden2tag(lstm_out.view(len(sentence), -1))
        tag_scores = F.log_softmax(tag_space, dim=1)
        return tag_scores

# training the model 
model = LSTMTagger(EMBEDDING_DIM, HIDDEN_DIM, len(word_to_ix), len(tag_to_ix))
loss_function = nn.NLLLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# See what the scores are before training
# Note that element i,j of the output is the score for tag j for word i.
# Here we don't need to train, so the code is wrapped in torch.no_grad()
with torch.no_grad():
    inputs = prepare_sequence(training_data[0][0], word_to_ix)
    tag_scores = model(inputs)
    print(tag_scores)

for epoch in range(300):  # again, normally you would NOT do 300 epochs, it is toy data
    for sentence, tags in training_data:
        # Step 1. Remember that Pytorch accumulates gradients.
        # We need to clear them out before each instance
        model.zero_grad()

        # Step 2. Get our inputs ready for the network, that is, turn them into
        # Tensors of word indices.
        sentence_in = prepare_sequence(sentence, word_to_ix)
        targets = prepare_sequence(tags, tag_to_ix)

        # Step 3. Run our forward pass.
        tag_scores = model(sentence_in)

        # Step 4. Compute the loss, gradients, and update the parameters by
        #  calling optimizer.step()
        loss = loss_function(tag_scores, targets)
        loss.backward()
        optimizer.step()

# See what the scores are after training
with torch.no_grad():
    inputs = prepare_sequence(training_data[0][0], word_to_ix)
    tag_scores = model(inputs)

    # The sentence is "the dog ate the apple".  i,j corresponds to score for tag j
    # for word i. The predicted tag is the maximum scoring tag.
    # Here, we can see the predicted sequence below is 0 1 2 0 1
    # since 0 is index of the maximum value of row 1,
    # 1 is the index of maximum value of row 2, etc.
    # Which is DET NOUN VERB DET NOUN, the correct sequence!
    print(tag_scores)
>>>> tensor([[-1.1389, -1.2024, -0.9693],
        [-1.1065, -1.2200, -0.9834],
        [-1.1286, -1.2093, -0.9726],
        [-1.1190, -1.1960, -0.9916],
        [-1.0137, -1.2642, -1.0366]])
tensor([[-0.0462, -4.0106, -3.6096],
        [-4.8205, -0.0286, -3.9045],
        [-3.7876, -4.1355, -0.0394],
        [-0.0185, -4.7874, -4.6013],
        [-5.7881, -0.0186, -4.1778]])

Learn more

Read how you can keep track of model training metadata with TensorFlow + Neptune integration or PyTorch + Neptune integration.

Hugging Face

The transformer model has advanced NLP significantly in recent years. It’s essentially a novel architecture which takes into account the long-term dependency when solving sequence-to-sequence tasks. For the most part, NLP models are quite large and require quite a lot of compute to get a decent working model. The Hugging Face Python framework provides access to a number of pretrained models for a variety of NLP tasks. Even the likes of Amazon, Google AI, and Facebook AI leverage this package.

Below is an example of the Hugging Face pipeline for Sentiment Analysis – you can read more about this in the documentation.

from transformers import pipeline

# a sentiment analysis pipeline
clf = pipeline("sentiment-analysis")

# creating dummy dataset
data = ["I am happy to be reading this article",
        "I am not happy to read this article",
        "This is a really informative article",
        "Thank you for reading"]

# classifying each instance
results = clf(data)

for result in results:
  print(f"label: {result['label']}, score: {round(result['score'], 4)}")

>>>> label: POSITIVE, score: 0.9999
     label: NEGATIVE, score: 0.9989
     label: POSITIVE, score: 0.9998
     label: POSITIVE, score: 0.9998

Project Management tools for NLP projects

Similarly to traditional Machine Learning projects, NLP projects are highly iterative. On your journey through the project lifecycle, it’s not uncommon to iterate on a particular section until your NLP system meets some desired intrinsic performance level. Intrinsic evaluations are more focused on intermediary objectives, such as how the NLP component performs on a defined subtask.

Once a project is deployed into a production environment, it’s still far from finished. Interactions, feedback and changes in the real world would alter the requirements for your current NLP component, which would mean cycling back to an earlier step within the project’s lifecycle to update (or improve) it.

To get your NLP projects over the line, there are a variety of tools to help not only the developers, but also members of the AI team who may not be as technical. These tools include messaging apps, experiment management tools, tracking tools, and more. Here’s a list of valuable project management tools that you might want to use for your NLP projects:

neptune.ai

neptune.ai is a lightweight experiment tracking and model registry. It heavily promotes collaboration, and it can track all of your experiments. It’s quite flexible and integrates well with a number of frameworks (including the ones mentioned above). Using this tool, you can log, store, display, organize and query all of your Machine Learning Operations (MLOps) metadata.

What does Neptune provide?

Logging and displaying metadata for Machine Learning Models
Hub to organize experiments and model training runs
Easily compare experiments and Machine Learning models
Watch your Machine Learning experiments run live
Reproducible experiments and model training runs
A special link to share visualizations with team-mates
Programmatically query experiment and model training metadata
Run your code from absolutely anywhere (laptop, cloud infrastructure, or a cluster)

MLFlow

A cool thing about MLFlow is that you can use it with any Machine Learning library and any programming language, since all of the available functions are accessed through a REST API and CLI. Beyond its accessibility from a technical standpoint, the MLflow documentation is extremely well written and easy to follow. The documentation states that:

“MLflow is an open source platform for managing the end-to-end machine learning lifecycle. It tackles four primary functions:

Tracking experiments to record and compare parameters and results (MLflow Tracking).
Packaging ML code in a reusable, reproducible form in order to share with other data scientists or transfer to production (MLflow Projects).
Managing and deploying models from a variety of ML libraries to a variety of model serving and inference platforms (MLflow Models).
Providing a central model store to collaboratively manage the full lifecycle of an MLflow Model, including model versioning, stage transitions, and annotations (MLflow Model Registry).”

And that essentially sums up everything that MLflow provides – I told you their docs are well-written.

Github

Github is the social networking site for developers. It provides internet hosting, as well as version control using Git, to over 56 million developers worldwide. Github makes collaboration easy and painless, with features that permit code hosting and reviews, thorough project management, and convenient software building. Typically, project managers and developers leverage Github to coordinate, track, and update their work in a single environment.

The platform has many features, and each feature is multifaceted. Holistically, the features provided by Github fall into one of seven categories:

Collaborative Coding
Automation & Continuous Integration/Continuous Development (CI/CD)
Security
Client Applications
Project Management
Team Administration
Community

Comet ML

NLP tool - Comet — *Source:* *Introducing Comet.ml Project Visualizations*

The homepage of Comet.ML’s website states “Comet.ML allows Data Scientists and developers to easily monitor, compare, and optimize their Machine Learning models” – it doesn’t get much clearer than that. One of the most popular features are their live experiments charts; Comet.ML gives you a compelling dashboard that binds together the code of your ML experiments and their results, as well as features that help practitioners optimize their models by tweaking hyperparameters.

NLP projects are similar to traditional software applications in many ways, but also quite different. It’s similar because both applications are crafted in a controlled development environment. It’s different because NLP and Machine Learning projects typically also include data that comes from a never-ending source called the real world – therefore the data we used to build the application also must be tracked.

This is where Comet.ML comes in. Comet.ML lets users:

Track datasets,
Track changes to code,
Track experiment history and machine learning insights.

Additionally, Comet.ML provides valuable insights and data for practitioners to build better models, faster, while also improving productivity, collaboration, and explainability.

Slack

Think of WhatsApp, Facebook Messenger, or iMessage… now give it steroids. That’s Slack. Slack is a messaging application meant for teams and entire work organizations. It can be used across a variety of different devices and platforms. The application has numerous robust features that let individuals communicate in various chat rooms, as well as in one-to-one rooms – ever since the global pandemic hit, Slack has risen to be a valuable tool for businesses and teams.

To keep all members of the team aligned, there are various features such as:

Channels – a central space for conversations. There could be multiple channels for various topics (i.e. Resources, Support, Project 1).
Slack Connect – collaborate with teams from different companies (great for companies involved in B2B services)
Voice and Video Calls

Slack has a number of applications and integrations that boost productivity across the board. My personal favourite is the Google Drive integration, which lets users share and manage access to files, as well as receive updates and much more, all within Slack. There are also integrations for other common apps like OneDrive, Zoom, and Outlook.

Jira

Jira was developed by Atlassian for proprietary issue tracking, making it a great tool for teams to plan out projects, track projects, and release products or software in a flexible and automated fashion. This tool is great for agile teams, since it embraces project management. Users can freely manage their projects, assign tasks to team members (including bugs to programmers), create milestones, and plan tasks with designated deadlines.

Some of Jira’s features include (read more about these features on the Jira Features page):

Scrum Boards
Kanban Boards
Roadmaps
Agile Reporting

Jira is popular, and a very appropriate solution for NLP projects, as it promotes collaboration as well as simplifying, organizing, and structuring workflows.