Learn Large Language Models (LLMs) with Python and LangChain

Explore transformers overview to build language models, address long-range word relationships, and learn self-attention, word embeddings, and parallelization that power models like ChatGPT.

Explore the word2vec skip-gram model, window size, one-hot encoding, and the embedding matrix that learns word vectors to reveal semantic similarities.

Learn how positional encoding combines word embeddings with sine and cosine vectors to encode token positions in transformer inputs, enabling parallel processing, deterministic position values, and extrapolation to longer sequences.

Explore the self-attention mechanism at the heart of transformers, showing how queries, keys, and values compute attention scores to reveal word relationships in an input sequence.

Train transformers by predicting the next word from a sequence and updating the query, key, value, and embedding matrices using backpropagation, ground-truth labels, and cross-entropy loss.

Explore encoder-only architectures like BERT, which encode input into fixed-length embeddings for sentiment analysis, text classification, and language understanding, without text generation.

Explain bidirectional self-attention in Bert and how encoder-only transformers attend to left and right contexts, enabling parallel processing and a discriminative setting that extracts answers from context.

Learn how the CLS token summarizes an input sequence in bert-based architectures, its role across transformer layers, and how the classification vector enables sentiment analysis and text classification.

Builds on Bert pre-training and fine tuning to predict the start and end of an answer within a context, using classification, separator, and segment embeddings.

Bert and Roberta share an encoder-only transformer with bidirectional attention. Roberta uses dynamic masking and more data, omitting next sentence prediction compared to Bert's static masking and next sentence prediction.

Explore the sentiment analysis implementation and leverage Google Colab to bypass local setup, using NumPy, TensorFlow, PyTorch, and Keras, with GPU or CPU runtimes to accelerate deep learning.

Demonstrate tokenization for sentiment analysis by converting text to token IDs with CLS and separator tokens, applying 512-token padding and attention masks, and creating IMDb train/test splits in PyTorch.

Set up a data loader and train a bert-based sentiment classifier with batching, padding, and shuffle, using cross-entropy loss and the adam optimizer at a small learning rate.

Explore text classification with a transformer-encoder and a dense network, using a data loader, cross-entropy loss, and Adam optimizer across 20 epochs for about 88% test accuracy.

Use a built-in head of a pre-trained Bert-like architecture via auto tokenizer and auto model for sequence classification, train with the transformers trainer, and compare accuracy and precision.

Fine-tune a Bert model for question answering on a custom dataset by aligning start and end character positions, using context and questions with segment embeddings and Python tools.

Install transformers and datasets in Google Colab, train a BERT-based question answering model on a small dataset on CPU to avoid overfitting, and upload a custom bird question answering JSON.

Parse a custom bird QA JSON, convert it to a Hugging Face dataset, and assemble training data with context, questions, and answers for BERT-based question answering.

Parse a Hugging Face JSON dataset to build a bert-based question answering pipeline, tokenize with bert-large-uncased, and map inputs with input ids, attention masks, and start/end positions.

Train and fine-tune the Bert large uncased whole word masking model for question answering on squad, covering full architecture, head training, small learning rates, and trainer setup.

Fine-tune an encoder-only Bert model for question answering, test with a helper function, manage device and tokenization, and extract answers from context, while signaling future shift to GPT models.

Explore decoder-only architectures like GPT and Lama, their autoregressive generation, and why fine-tuning these large language models is costly; learn efficient approaches to fine-tune attention.

Compare transfer learning and fine tuning for decoder-only models, focusing on freezing layers, the head, and low-rank adaptation (LoRA) for small-data tasks.

Learn how decoder-only large language models like GPT use next-token prediction and cross-entropy loss, then fine-tune with reinforcement learning from human feedback using PPO and a reward model.

Learn low rank adaptation (LoRA) to reduce fine-tuning parameters of decoder-only language models by exploiting matrix rank and linearly independent columns to boost efficiency.

Explore how low rank adaptation freezes transformer matrices and uses small A and B adapters to form w' = W + AB, enabling efficient fine tuning with fewer parameters.

Learn quantized low-rank adaptation (qlora) to reduce memory footprint and accelerate fine-tuning of decoder-only LLMs, using post-training quantization or quantization-aware training.

Learn to use GPT-2 with pipelines and the auto causal LM model for fine-tuning and control over hyperparameters, tokenizer, precision, device usage, and model sizes from small to extra large.

Explore configuring a GPT-2 based model with auto tokenizer or explicit name, enable half-precision loading, and distribute across hardware to support next-token prediction and token embeddings.

Learn how to generate text with the GPT-2 model using the tokenizer, the prompt, and parameters like max length, temperature, and repetition penalty, then decode the output.

Learn to use the llama model with transformers in python, including 1.1 billion parameters, 16-bit precision, auto tokenizer and device map, to generate answers from prompts and preview fine-tuning.