Generative AI - Natural Language Processing Bootcamp 2026

Learn the NLP pipeline from data acquisition and text cleaning to preprocessing, including tokenization and lower casing, then feature engineering, modeling, evaluation, deployment, and monitoring.

Learn hands-on data extraction and text cleaning in an NLP pipeline by building a Scrapy project to scrape books, extract items, and save results to a CSV file.

Explore the NCTC library and its text preprocessing tools, including tokenization and tagging for NLP tasks. Learn stop words removal, stemming, and named entity recognition.

Perform tokenization in a hands-on session using the Punkt package in Google Colab. Generate bigrams, trigrams, and n-grams from the tokenized text to analyze word patterns.

Explore part of speech tagging and stop words removal with hands-on tokenization using an analytics library, demonstrating how POS tags reveal context and how stop words are filtered during preprocessing.

Explore stemming and lemmatization to reduce inflected words to root forms, compare Porter, Snowball, Lancaster, and regex methods, and apply effective preprocessing in text data.

Explore named entity recognition and word sense disambiguation within natural language processing, then implement the Lesk algorithm in Python to resolve word meaning in context.

Explore the Spacey library for production-ready natural language processing in Python, covering tokenization, part of speech tagging, parsing, lemmatization, named entity recognition, and serialization.

Explore the Spacey library hands-on by loading an English small model, creating an NLP object, and running tokenization plus the default pipeline for tagging, parsing, and named entity recognition.

Discover the core components of an NLP pipeline, learn text pre-processing to reduce features, and represent text data numerically to boost model accuracy; next, explore text factorization.

Explore text factorization as feature extraction to convert raw text into numerical vectors using one hot encoding, and review its sparsity and limits like no word order or context.

Master the bag of words technique, representing documents by word occurrence in a fixed-length vector. Compare it with one-hot encoding and note its advantages and limitations.

Implement the bag of words technique in Python with preprocessing, tokenization, and count vectorizer, while exploring unigrams and n-grams and their advantages and disadvantages for text data.

Demonstrates tf-idf, combining term frequency and inverse document frequency to quantify word importance within a document and across a corpus, with practical calculations.

Compute tf-idf scores by combining term frequency and inverse document frequency to emphasize document-specific terms, using Python and sklearn in a hands-on session comparing tf-idf to count vectors.

Explore tf-idf from scratch: compute term frequency and inverse document frequency to weight words in a corpus, build a vocabulary, apply L2 normalization, and validate against scikit-learn's tf-idf vectorizer.

Explore word embeddings, a numerical vector representation of words that captures semantic and syntactic meaning, and see how pre-trained models support text classification tasks like tweet analysis.

Explore fixed-length vector representations and word embeddings via word2vec, using language modeling to capture context, then measure similarity with cosine distance and prepare for pre-trained CBOW and skip-gram models.

Load and inspect a pre-trained word2vec model with gensim. Verify vocabulary and word presence, view 300-dimensional vectors, and compute cosine similarities to compare words.

Explore the skip-gram word embeddings model, compare it with continuous bag of words, and learn to generate training pairs by predicting surrounding context words with a one-hidden-layer neural network.

Explore the skip gram model architecture: map one hot inputs from a 10,000 word vocabulary to 300 feature word vectors in a dense hidden layer with a softmax output.

Train a skip-gram word2vec model from scratch on a Stanford cell phone and accessories reviews dataset using gensim, preprocess text, build vocabulary, train, save, and explore word embeddings via similarity.

Learn the continuous bag of words CBOW architecture as an alternative to skip-gram in word2vec, using bag-of-words inputs, context word averaging, and a softmax output.

Explore subsampling and negative sampling in skip-gram word embeddings to reduce training data, bias context weights, and build efficient high-quality embeddings for large vocabularies.

Analyze the practical differences between skip-gram and continuous bag of words, noting how window size affects training samples and time, and how each approach shapes word representations and syntactic capture.

Learn how a word2vec style network trains word embeddings using skip-gram with negative sampling. The lecture covers forward passes, back-propagation, and updating input and output weight matrices.

Review how text data is represented, from basic approaches to word embeddings and deep learning methods, and note that the best approach depends on domain and data for text classification.

Explore the end-to-end pipeline for text classification, from data labeling and feature extraction to training, evaluation, and deploying a text classifier for sentiment, spam, and language detection.

Explore approaches to text classification in real-time projects, comparing off-the-shelf services like Amazon Comprehend and Google Cloud Natural Language with custom models, focusing on sentiment and entity extraction.

Load the sentiment training dataset and classify movie reviews as positive or negative. Use pandas to read text and sentiment data, adjust display width, and filter to show samples.

Explore data with exploratory data analysis to assess sentiment distribution and metadata, then preprocess text using bag-of-words, building a vocabulary and sparse count vectors.

Prune low frequency words during text preprocessing using count vectorization, histogram analysis, and feature counts to refine vocabulary and remove uninformative top words for sentiment analysis.

Remove stop words and apply stemming or lemmatization to streamline text features before vectorization. Extend default stop words with domain-specific terms to analyze word distribution across sentiments.

Analyze how word sentiment distribution reveals positive, negative, and neutral cues, then build a Bernoulli Naive Bayes classifier to predict sentiment from features.

Implement tf-idf vectorization with stemmed words and a 1000 feature limit, fit on training text, then train a Gaussian NB classifier and evaluate with a classification report.

Navigate text analysis challenges such as domain variation and informal social media language, and learn to overcome bag-of-words limits with n-grams, stemming, and tf-idf for NLP models.

Explore named entity recognition in natural language processing and how entity extraction classifies text. See a case study and chat bot use cases for person and organization.

Explore named entity recognition with conditional random fields, detailing sequence modeling, feature functions, and how embeddings, neighboring words, POS tags, and gazetteers improve entity extraction.

Explore what a chat bot is and how natural language processing enables conversational interfaces across platforms like Facebook Messenger, Google Assistant, Alexa, and Siri, tracing history from Eliza to apps.

Build a simple search-based chat bot that maps user questions to nearest predefined queries and returns relevant answers, then apply a process from goal setting to testing and tone refinement.

Load the dataset, clean missing values, apply tf-idf text processing, and test a simple faq chatbot that uses cosine similarity to match user questions to answers.

Explore chat bot types: fake based, flow based, and open ended, and map them to a dialogue system pipeline from speech recognition to text to speech.

Uncover key chatbot terminologies, including intent, entities (slots), actions, and stories, and see how they drive conversation flow and integration with dialog systems like Dialogflow in Google Cloud.

Explore Dialogflow, a Google Cloud NLP platform that enables lifelike chatbots across more than 20 languages and 14 platforms, with serverless development, sentiment analysis, spelling correction, and knowledge connectors.

Learn the basics of Dialogflow: convert user input into intents and entities with training phrases, parameters, and responses to build chatbots, with fulfillment and platform integrations.

Set up Google Cloud Platform and Dialogflow Essentials to build chatbots, understanding cloud computing, billing, and console access for hands-on practice.

Build and test a Dialogflow chatbot by importing an agent, creating intents and entities, configuring training phrases and parameters, and validating responses in the Dialogflow simulator.

Implement Dialogflow fulfillment by integrating your agent with services using cloud functions and the inline editor, deploying node.js code and testing in the simulator.

Explore Dialogflow integrations and deployment, configure web demo, Telegram, and other channels, and deploy the bot while you build it with fulfillment, training phrases, and entities.

Learn to create and manage Dialogflow knowledge bases and documents, enable beta features, and use the training tool to refine agent conversations with ML settings.

Explore the components of a dialog system, including intent classification, entity extraction, context and dialogue act handling, and various response generation methods, fixed, template-based, and automatic.

Explore dialog intent prediction as a multiclass classification task, using the eighties data set with 17 intents and train, development, and test splits; prepare to implement this in hands-on practice.

Explore deep learning for dialogue intent classification using the eighties dataset; build a TensorFlow CNN with pre-trained word embeddings, padding, and one-hot labels, achieving strong test accuracy.

Explore how to design, build, and deploy a Rasa chatbot using its open source NLU and dialogue management architecture, including goals, personality, task flow, and multi-channel integration.

Set up a conda virtual environment, install Rasa and spaCy, and download a language model, then initialize a Rasa project and train a demo model to run the bot.

Explore the Rasa project structure for building a chat board, including nlu data, intents, rules, domain, stories, and a configuration pipeline.

Explore the Rasa project structure for a chat bot, including training data, domain and policy files, and learn to train, run, and visualize stories with key commands.

Explore YAML basics, including its data types, indentation rules, and syntax, learn to create and structure YAML files with arrays, nesting, and multi-line values for configuration.

Develop and test a custom chatbot by creating a new intent and responses using YAML and domain files, training the model, and validating uttered text outputs.

Build a chatbot by extracting entities from user input and storing them in slots using YAML training data, intents, and domain mappings, with hands-on Raza demonstrations.

Create a New York Times developer account, generate and note your API key and secret, and enable the required APIs to access data for building a chatbot.

Demonstrate how to implement custom actions in Rasa, using the dispatcher to send responses, configure the action endpoint, and train and test with domain and stories.

Learn to build a custom action that extracts a user category, calls the NY Times API, and presents news results, wiring intents, entities, and a custom server.

Test the action server and retrain the model to verify the action endpoint and separate servers operate correctly, with fashion and news category handling.

Delve into the configuration yaml of a Rasa pipeline, exploring tokenization, feature engineering, the diet classifier, entity extractors, and how rule, memorisation, and TED policies determine next actions.

Set up your deployment environment by creating a Slack account and workspace, installing end grok via homebrew, and preparing to integrate your chat bot with the Slack channel.

Expose a locally running rasa chatbot to the internet using ngrok, forwarding requests from a public URL to port 5005, and prepare for Slack integration.

Connect a Rasa chatbot to Slack by configuring credentials, creating a Slack app, obtaining token and signing secret, enabling events and webhooks, and testing end-to-end channel integration.

Explore a concert board project from the Raza team, highlighting YAML-based intents, slots, and actions, with end-to-end pipeline and a custom action that calls the New York Times API.

Explore text summarization, a natural language processing task that creates concise summaries from longer text using extractive methods, with use cases in news highlights and search index reduction.

Explore a Python text summarizer workflow: extract and preprocess paragraphs, tokenize, compute weighted word frequencies, rank sentences, and generate a summary, with a hands-on example using Beautiful Soup and NLTK.