Natural Language Processing in Python

Install Anaconda to write Python code in a Jupyter notebook. Explore Anaconda's features, launch Jupyter notebook, and learn to create and activate conda environments for course assignments.

Explore Anaconda, the leading package and environment manager used by data scientists, and learn how it streamlines Python and R workflows with Jupyter Notebook and RStudio.

Download Anaconda for macOS or PC, select Apple Silicon or Intel, and skip registration. Run the installer with default options and launch Anaconda to begin.

Launch Jupyter Notebook from Anaconda, open the interface in your browser, create a Maven NLP folder and notebook, rename it, and start writing Python code in cells.

Learn to use conda environments to isolate Python versions and libraries for each project, ensuring reproducible outputs with numpy, Vader sentiment, Transformers, and PyTorch.

Create a new conda environment, activate it, and install the transformers library from hugging face with its dependencies. Launch Jupyter Notebook in that environment to run Python code, then deactivate.

Explore conda commands to view, create, and activate environments, install packages, and use YAML files to rapidly create environments from the terminal.

Learn to create and manage conda environments, switch between base and test, install pandas, launch Jupyter Notebook, and troubleshoot spacey import errors, then deactivate to base.

Create and manage four conda environments for this course to stay organized and avoid version conflicts, using step-by-step lessons or YAML files.

Kick off NLP 101 by exploring the basics of natural language processing, its history and evolution, key techniques and applications, and a survey of Python NLP libraries.

Learn how natural language processing uses computers to work with text data, bridging AI and machine learning, with examples like sentiment analysis and text summarization.

Trace the evolution of natural language processing from 1950s machine translation and Eliza to modern transformers, highlighting the shift from rules-based and probabilistic methods to deep learning.

Explore traditional and modern NLP techniques, from rules-based methods and Naive Bayes to large language models, applied to sentiment analysis, text classification, topic modeling, and embeddings-based document similarity.

Explore Python NLP libraries like spaCy, Vader, and Transformers, alongside pandas and scikit-learn, for cleaning, sentiment analysis, topic modeling, and text generation.

Explore how natural language processing uses computers to work with text. Compare rules-based and sentiment analysis methods, and note when simple approaches outperform transformers on smaller datasets.

Master pre-processing for ml algorithms with cleaning, normalization, and vectorization, and learn the nlp pipeline using pandas and spacy to turn text into numeric features via word counts and tf-idf.

Follow the data science workflow for NLP, with a text pre-processing step between cleaning and exploration. The NLP pipeline turns raw text data into data and analysis results to share.

Learn how text preprocessing turns raw text into numeric data for analysis and modeling by cleaning and normalizing text, then vectorizing with document-term matrices and TF-IDF.

Create a conda environment named NLP basics, install Python and NLP libraries, and launch a Jupyter notebook to verify proper setup for the assignment.

Create and activate a dedicated NLP basics environment with conda, install Python, Jupyter Notebook, pandas, Spacy, scikit-learn, and matplotlib, then launch Jupyter and run a simple print.

Leverage pandas for text preprocessing by lowering case, removing punctuation and bracketed text with regex, and creating a sentence clean column from the raw text in Python notebooks.

Open the course materials and notebooks, then set up a text preprocessing demo in pandas to create two data sets and adjust display options.

Demonstrates text preprocessing in pandas by creating a copy of the data frame, lowercasing text, removing square-bracket content, applying regex to strip recipes and Wikipedia, and removing punctuation.

Learn to encapsulate text preprocessing in a reusable Python function using def, lowercasing text, removing square brackets and punctuation, and returning cleaned output for any data series.

Apply text pre-processing with pandas to read the children's books csv into a Jupyter notebook and clean the description column by making text lowercase, removing special characters, and removing punctuation.

Learn to preprocess text with pandas by loading a csv, creating a dataframe, and cleaning the description column: lowercasing, removing non-breaking spaces, and stripping punctuation with a regex.

Preprocess text with spaCy, turning strings into a spaCy document to perform tokenization, lemmatization, and stopword handling using the English model. Build and explore spaCy workflows with demonstrations.

Learn how tokenization splits text into tokens, using Spacy to break on whitespace and handle contractions and punctuation, producing smaller text units for NLP tasks.

Learn lemmatization in spaCy to reduce words to their base forms for text normalization, and see how tokenization and stemming compare using lemon and lemons examples.

Identify stopwords and filter them from text with a list comprehension and Spacy's stopword check. See how removing I and four clarifies meaning, and note that cleaning is never perfect.

Explore parts of speech tagging in spaCy to label words as nouns, verbs, and more, using it as a filtering technique before applying other machine learning algorithms.

Learn how to pre-process text by tokenizing with spaCy, lemmatizing, and removing stop words, then join tokens into a cleaned string for NLP analysis.

Learn to build a reusable python function that tokenizes, lemmatizes, and removes stopwords with spaCy and pandas, and apply it to datasets using dot apply.

Explore parts of speech tagging with spaCy, turning a sentence into a document, extracting tokens with their part-of-speech labels, and filtering to nouns for focused analysis.

Build an NLP pipeline that combines lowercasing, lower replace, token lemma non-stop, and parts-of-speech filtering into a single function, then apply it to series and data frames.

Learn to perform text preprocessing with spaCy, building on earlier pandas-based cleaning, including tokenization, lemmatization, stopword removal, and normalization of a description column.

Preprocess text with spaCy in Python by tokenizing, lemmatizing, and removing stopwords. Define a function and apply it to a dataframe column to produce a cleaned text description.

Learn to vectorize text by turning it into numeric data using document-term matrices and word counts. Explore tf-idf and future embeddings to enhance machine learning with text data.

Explore how to create a count vectorizer, build a document term matrix, and tune parameters such as stopwords, ngram range, and min df in Python with scikit learn.

Instantiate a CountVectorizer from scikit-learn, fit and transform a text clean series into a document term matrix, convert the sparse CSR to a readable dataframe, and attach term names.

Explore how to customize count vectorization by adjusting token patterns, stopwords, and word frequencies. Learn to tune n-grams and document frequency thresholds to control features and improve performance.

Perform quick exploratory data analysis on a document-term matrix to compute term frequencies, create a horizontal bar chart for readability, and sort terms from highest to lowest for clear visualization.

Vectorize cleaned text with CountVectorizer to create a document-term matrix, remove stopwords, set a minimum document frequency, and visualize the top ten and least common terms.

Vectorize the cleaned text with CountVectorizer to build a document term matrix, remove stopwords, set a min document frequency, identify top and bottom terms, and plot a horizontal bar chart.

Explore tf-idf by combining term frequency normalization with inverse document frequency to emphasize rare, informative words in a document-term matrix, then implement it in Python.

Learn to implement a Tfidfvectorizer in Python, using fit transform and transform, mirroring CountVectorizer. Understand how tf-idf scores replace word counts and how stopwords, bigrams, and min_df affect document-term matrix.

Demonstrate how to implement the tf-idf vectorizer and compare it to the count vectorizer, showing fit-transform, term weighting, and how tf-idf scores reflect term rarity to build a document-term matrix.

Compare tf-idf vectorizer with count vectorizer by vectorizing cleaned text, experimenting with stopwords and min and max df, and plotting the top ten terms as a horizontal bar chart.

Compare CountVectorizer and TF-IDF vectorization on document term matrices in Python, tune stopwords, min_df and max_df, and visualize the top weighted terms for insight across the corpus.

Review the nlp pipeline from raw text to transformed data, covering cleaning, normalization, bag-of-words, and tf-idf, with pandas and spacy, plus tokenization, lemmatization, stopword removal.

Explore traditional NLP methods, including rules-based sentiment analysis, text classification, and topic modeling. Practice supervised and unsupervised approaches with Vader, Naive Bayes, logistic regression, and non-negative matrix factorization.

Discover how machine learning, a subset of artificial intelligence, lets computers learn from data and make predictions or uncover patterns with supervised and unsupervised techniques.

Explore supervised and unsupervised machine learning algorithms—regression, classification, clustering, dimensionality reduction, Naive Bayes, and non-negative matrix factorization—that apply to natural language processing on vectorized text data.

Explore traditional NLP methods through sentiment analysis with Vader, text classification with Naive Bayes in scikit-learn, and topic modeling with NMF on vectorized text.

Start simple when choosing between traditional and modern NLP; use traditional techniques for small to medium data and simple goals, and modern methods for large data or complex tasks.

Watch this demo to create a new NLP machine learning environment with conda, install openpyxl and numpy, use conda forge for Vader sentiment, download spaCy English models, and launch Jupyter.

Explore sentiment analysis as a core NLP task that scores text from negative one to positive one, indicating positivity or negativity.

Explore sentiment analysis in Python with the Vader library, using polarity scores and compound scores to classify informal text via rule-based weights and modifiers.

Learn sentiment analysis in python using the vader sentiment intensity analyzer to compute polarity and compound scores, then apply a get_sentiment function to a data frame's text column.

Set up a natural language processing environment in Python, launch Jupyter notebook, apply sentiment analysis to the movie review csv’s info column, and identify top ten feel-good and darkest movies.

Set up a new nlp environment, load movie reviews with pandas, and apply Vader sentiment to compute compound scores. Sort by sentiment to reveal top and bottom movies.

Explore text classification in natural language processing using supervised learning, where pre-labeled emails and support tickets train a model to label new text as spam or issue type.

Vectorized text data can be fed into any classification algorithm, with Naive Bayes for small data and logistic regression for medium data in a practical NLP workflow.

Explore how Naive Bayes uses Bayes theorem for text classification by assuming conditional independence, illustrated with spam email examples. Build a Python Naive Bayes model with pre-labeled data.

Apply multinomial Naive Bayes in Python with scikit-learn, using countvectorizer or tfidfvectorizer inputs to fit a model and predict spam or not spam.

Demonstrate naive bayes for text classification to flag high-priority versus low-priority reviews. Build a scikit-learn workflow using count and tf-idf vectorizers, naive bayes, and text cleaning.

Vectorize the text with countvectorizer, build a document-term matrix, and train a multinomial naive bayes model to predict high versus low priority reviews, with train-test split and accuracy 0.84.

Predict low or high priority for new reviews using a Naive Bayes model by cleaning text, transforming with a pre fit count vectorizer, and predicting.

Compare ml models for text classification by switching from countvectorizer to tf-idf vectorizer and from Naive Bayes to logistic regression, then evaluate with accuracy and other metrics.

Fine-tune text classification by refining the NLP pipeline, from cleaning and normalization to feature engineering and vectorization choices. Adjust probability cutoffs and model types to improve results.

Develop text classification in Python to predict directors' gender from movie descriptions, using a count vectorizer with stopword removal and Naive Bayes or logistic regression; identify top five female-directed films.

Clean and normalize movie info with Maven, vectorize using CountVectorizer, remove stopwords, min df 10%; train Naive Bayes and logistic regression to predict director gender and identify female directed films.

Explore topic modeling as an unsupervised NLP method that extracts themes from unlabeled documents and requires human interpretation to name topics.

Vectorize text data into numeric form for topic modeling; apply NMF with scikit-learn for small data, LDA for medium data, and embeddings Bert topic and Top Topic for large data.

Explore non-negative matrix factorization (NMF) for topic modeling by decomposing a document-term matrix into a document-topic (W) and a topic-term (H) matrix, enabling dimensionality reduction for NLP tasks.

Explore NMF in Python with scikit-learn, using CountVectorizer or TfidfVectorizer, tuning n_components from two upward and applying fit_transform to reveal topic terms.

This demo uses non-negative matrix factorization on tf-idf vectorized reviews to uncover topics, adjusts min_df and max_df, and examines the W and H matrices to display topic terms.

Explore a display topics function for an optional lesson, extracting top terms from the H matrix of an NMF model using argsort and the tf-idf vectorizer term list.

Tune an nmf model by varying topics, inspect the w and h matrices, and map topics to reviews to interpret flavors, health, and orders.

Enhance topic modeling by tuning the NLP pipeline, pre-processing, and vectorization with Tfidfvectorizer and Countvectorizer. Explore models such as NMF, LDA, LSA, Bert topic, or Top2Vec for interpretation and fine-tuning.

Combine topic modeling, sentiment analysis, and exploratory data analysis to assign topics and measure sentiment by topic. The demo reveals taste and texture drive sentiment, while orders may need improvement.

Use topic modeling to uncover film themes with a tf-idf vectorizer from the Maven pre-processing module, applying stopwords and min/max document frequency, then identify two topics and top movies.

Master topic modeling with tf-idf vectorization and NMF to uncover themes in movie descriptions and map documents to topics.

Apply machine learning to text data across traditional and modern nlp, using Vader and Textblob for sentiment, naive bayes and logistic regression for text classification, and nmf for topic modeling.

Explore the shift from traditional NLP to modern NLP, and build foundational understanding of neural networks, deep learning, logistic regression, MLPs, and transformers through visuals and Python demos.

Transition from traditional to modern NLP using transformers and large language models, from neural networks basics to pre-trained LLMs like BERT and GPT, with Hugging Face applications.

Explore how neural networks, a model inspired by neurons, process data from input to output through hidden layers, with nodes, parameters, and activation functions guiding predictions.

Demonstrate logistic regression as a classification tool for neural networks, mapping temperature to probability via a sigmoid, via a two-step process of a linear transformation and a nonlinear transformation.

Explore how logistic regression maps to a simple neural network, using input features like temperature and weekend, with linear transformations, sigmoid activation, and layered nodes to predict profitability.

Explore how a two-node hidden layer neural network transforms inputs like temperature and weekend into a final probability via weights and a sigmoid activation, compared with logistic regression.

Explore neural networks as a supervised learning approach with input, hidden, and output layers, weights and biases, a sigmoid activation, and the training process with scikit-learn.

Practice neural network concepts through an interactive exercise that reinforces lessons learned. View slides in the course exercises folder and watch the solution video for guidance.

Explore how a neural network diagram uses an input layer, two hidden layers, and an output layer, with weights, biases, and sigmoid activation at each node.

Learn how to build a neural network in Python using MLPClassifier or MLPRegressor in scikit-learn, configure hidden layers and activation functions, and understand when neural nets are used or avoided.

Explore neural networks for text classification by running a pre-built notebook, vectorizing text to a document-term matrix, and comparing Naive Bayes with a Mlpclassifier.

See how neural network weights and biases become matrices in a Python demo with four inputs and a two-node hidden layer to predict profitability, including matrix interpretations of the connections.

Explore neural network notation and matrices, mapping inputs to hidden and output layers. Understand how weights and biases form weight matrices and bias vectors across layers and transformers.

Learn how a neural network is trained in Python, from random initial weights and biases to forward passes, loss calculation, backpropagation, and gradient descent updates, repeated to minimize loss.

Explore a visual walkthrough of training a neural network, including forward passes and sigmoid activations. See how a lemonade dataset demonstrates random starts, weights, biases, backpropagation, gradient descent, and predictions.

Engage in this essential, interactive neural network training exercise to lock in new concepts and build on prior lessons, with a solution in the next video.

Discover neural network training: start with random parameters, perform forward pass, compute loss (log loss or MSE), backpropagate, and update with gradient descent or Adam to weights and biases.

Move from neural networks to deep learning with three or more hidden layers. Explore how deep learning powers natural language processing, computer vision, and speech recognition using large data sets.

Explore deep learning architectures, from feedforward neural networks to CNNs, RNNs, LSTMs, and Transformers, and see how embeddings and attention enable NLP and other data tasks.

Apply deep learning in natural language processing with pre-trained models and transfer learning. Use data to make predictions with a few lines of code on llms like Bert and GPT.

Explore how to use pre-trained deep learning models, as-is or via embeddings, and apply transfer learning or fine-tuning for tasks like sentiment analysis and text summarization, plus retrieval augmented generation.

Review key terms and concepts from the deep learning section to reinforce understanding and cement them in memory before the solution lesson.

Compare neural networks and deep learning, cover feedforward, convolutional, rnn and lstm architectures, and transformers; contrast traditional versus modern natural language processing with pre-trained models, embeddings, and fine-tuning.

Explore neural networks with input, hidden, and output layers; train them through forward passes, loss, and backpropagation, and see how transformers and CNNs power NLP and vision with pre-trained models.

Discover how transformers power popular large language models by exploring embeddings, attention, and feedforward layers, then learn encoder, decoder, and encoder-decoder categories and key models like GPT and BERT.

Recap the modern NLP concepts from neural networks and deep learning, cover the remaining key terms, and provide a high level overview of transformers and LLMs.

Explore how transformers compose embeddings, attention, and feedforward networks to power large language models pre-trained on vast text data, and clarify the difference between transformer architectures and llms.

Explore the transformer architecture: embeddings, attention, and a feedforward network drive final predictions, with context-aware vectors refined by attention to learn features across layers.

See how embeddings in the transformer's first layer convert raw text into high-dimensional vectors that position tokens by meaning. Learn how 768-dimensional embeddings capture semantic relationships.

Explore how attention in the transformer adds context to each token, with queries, keys, and scores shaping embeddings and model predictions.

Apply a feedforward neural network to transform representations from the attention layer, learning patterns in transformer inputs, and encoding them into weights for final predictions.

Explore how transformer architectures convert raw text into embeddings, apply attention to add context, and pass results through a feedforward network, highlighting parallelization and multi-headed attention.

Explore the transformer diagram from the original attention paper by breaking down embedding, attention, and feedforward layers, with positional encoding, add and norm, and multi-head attention driving learning.

Explore encoder only, decoder only, and encoder-decoder transformer models, and learn how raw text becomes embeddings for tasks like sentiment analysis, text generation, and translation.

Explore transformer-based large language models, categorized as encoder-only, decoder-only, and encoder-decoder, pre-trained on billions of words, with examples like Bert, GPT, T5, and Bart.

Practice transformers and LMS concepts through a three-section exercise over two slides, featuring drag-and-drop items and open-ended questions, like a quick quiz to test your knowledge before the solution video.

Explore transformer-based natural language processing concepts, including embeddings, attention, and feed-forward networks, and distinguish encoder-only, decoder-only, and encoder-decoder models. Learn how pre-trained LLMs enable text generation, translation, and text classification.

Explore transformer architecture from embeddings and attention to feedforward networks, with queries and key matrices shaping attention scores, and encoder, decoder, and encoder-decoder LLMs like BERT, ChatGPT, T5, BART.

Explore hugging face transformers and the transformers library to apply pre-trained models to six NLP tasks: sentiment analysis, named entity recognition, zero-shot classification, text summarization, text generation, and document similarity.

Explore Hugging Face, its Transformers library, and the model hub of pre-trained models, then apply a four-step workflow for encoder, decoder, encoder-decoder, and embeddings tasks, including sentiment analysis and summarization.

Create and activate a new conda environment named NLP transformers, then install python, jupyter, pandas, numpy, scikit-learn, openpyxl, and the transformers library with PyTorch.

Analyze sentiment with transformers using Distilbert in the Hugging Face pipeline, comparing encoder-only models to BERT, and apply to a text column with CPU or GPU.

Execute a sentiment analysis pipeline with Hugging Face transformers on a reviews dataset, compare Vader scores with Transformer-based predictions, and handle data loading, path fixes, and truncation.

Enhance a sentiment analysis pipeline by suppressing transformer warnings, timing execution in Jupyter, and speeding up with a GPU or a smaller data subset to compare CPU vs GPU performance.

Demo shows cleaning and aligning Vader and transformers sentiment scores using pandas, lambda functions, and axis=1 to compare positive and negative labels across a dataset.

Learn practical tips to accelerate transformers code in Python by using GPUs, choosing smaller models like Distilbert, enabling fast tokenization with Rust, tuning threads, and disabling gradients during inference.

Create an nlp transformers environment and launch a Jupyter notebook, then apply sentiment analysis to the movie info column in movie reviews csv using Transformers and compare with Vader scores.

Build a Python sentiment analysis workflow with the Hugging Face Transformers library and PyTorch, apply a sentiment analyzer to movie reviews, and compare transformer scores with Vader scores.

Learn named entity recognition (NER) with transformers, using BERT for entity extraction from text, and apply NER to data columns to extract people, organizations, and locations.

Set up a basic ner pipeline and run a named entity recognition analyzer on sample text. Configure the model, warnings, and aggregation to reveal organizations and locations.

Explore the Hugging Face model hub to compare NLP models for named entity recognition, identify the most downloaded fine-tuned BERT model for NER, and run analyzers to compare outputs.

Apply a named entity recognition analyzer across a dataframe column to extract and deduplicate entities, using list comprehensions, pandas apply, explode, and set filters for clean outputs.

Apply named entity recognition to book descriptions to extract named entities, then filter to include only people, with an optional extra credit step to exclude authors.

Apply named entity recognition to book descriptions in a dataset, extract and clean person entities, filter out authors, and refine results with Python and list comprehensions.

Explore zero-shot classification with transformers' Bart, a text-to-text encoder-decoder model, applying on-the-fly labels to categorize text without labeled data, using embeddings and probability scores.

Demonstrates building a zero-shot classification pipeline with a chosen model from the model hub, labeling text with predefined categories, and extracting the top label for datasets.

Apply zero-shot classification to label a book description column into five shelf categories, then compute category counts and validate a few books to see if they make sense.

Learn how to apply zero-shot classification in Python to categorize book descriptions into five labels, build a category column, and analyze category counts.

Explore text summarization with a Bart encoder-decoder model to reduce long text before applying sentiment analysis, and compare multiple sentiment scoring methods on original, truncated, and summarized data.

Build a text summarization pipeline in a notebook, selecting a Bert model from the model hub, fine-tuned on CNN Daily Mail, and tune min length, max length, and do sample.

Demonstrates using summarization as a truncation alternative to enhance sentiment analysis by applying two pipelines—summarization then sentiment analysis—on long texts.

Apply text summarization to the book description column to generate a short one-liner for each book, then review results to ensure they make sense.

Explore text summarization with transformers, tuning min and max length, early stopping, and length penalty, and apply to whole datasets using pipelines and dot apply.

Master text generation with a decoder-only model by crafting prompts, controlling outputs with max tokens and sampling via GPT-2, and leveraging OpenAI's GPT-4 via API for app development.

Explore document embeddings and cosine similarity to compare text similarity, using encoder-only models like Bert and a fine-tuned mini LLM to perform feature extraction and generate embeddings for downstream tasks.

Learn cosine similarity as a directional metric between data points, using angle between vectors; apply to document embeddings for measuring document similarity and aware of the curse of dimensionality.

Create movie embeddings using a feature extraction pipeline and cosine similarity to measure description based similarity. Retrieve similar movies with a get similar movies function using Captain Marvel as input.

Extract 384-dimensional embeddings for movie descriptions using a feature extractor, then compare to Captain Marvel via cosine similarity with a 166 by 384 embedding matrix.

Compute cosine similarities between embeddings using scikit-learn, convert to a pandas series, and sort to reveal the most similar titles to Captain Marvel.

Demonstrates building a general get similar movies function using NLP embeddings, feature extraction, and cosine similarity; convert Captain Marvel code to a reusable numpy-based pipeline with top-n results.

Learn to convert descriptions into embeddings, compute cosine similarity with Harry Potter and the Sorcerer's Stone, and identify the top five most similar books using language model embeddings.

Generate embeddings from book descriptions with a mini LM model and GPU, then compute cosine similarity to retrieve the top similar books.

Explore the transformers library to use pre-trained llms in python, select a task and model, apply it to text data, and compare outputs with embeddings and cosine similarity.

Review traditional natural language processing techniques, including rule-based sentiment analysis, naive Bayes, non-negative matrix factorization, and topic modeling with Vader and scikit-learn. Compare encoder-only and encoder-decoder models.

Practice next steps in NLP by applying text pre-processing and vectorization, then explore transfer learning, fine tuning, and retrieval augmented generation with pre-trained models.