LLMs Mastery: Complete Guide to Transformers & Generative AI

Discover the course structure of five parts, from theoretical foundations to practical coding with transformers, featuring Colab notebooks, Visual Code, and Hugging Face model weights.

Set up VS Code with the Python extension and interactive mode, run Jupyter notebooks in Colab, ensure GPU availability, and configure remote SSH for VS Code; consult resources for practice.

Explore the rule-based era of NLP, featuring manually crafted rules, syntax analysis, parsing, and part-of-speech tagging, and examine challenges like ambiguity and scalability that spurred statistical NLP.

Shifting from rule-based to data-driven NLP, researchers use probability. Utilize N-grams, probabilistic language models, and hidden Markov models for tagging and named entity recognition, despite data sparsity and semantics limits.

Explore how the machine learning era advanced natural language processing with Naive Bayes, SVM, and neural networks. Learn about RNNs and LSTMs for translation, sentiment, and text generation, highlighting scalability.

Discover how transformer models use encoder-decoder structure and attention to process language, with self-attention, multi-head attention, positional encoding, and layer normalization enabling parallel, efficient nlp tasks.

Explore how transformers use a two-phase training process—pre-training on large unannotated data and fine-tuning on task-specific data—to enable scalable, transferable NLP models.

Explore tokenization and embeddings in transformer models, comparing word, character, and subword methods, and see how context-aware embeddings drive language understanding and downstream tasks.

Explore BERT, the bidirectional encoder from transformers, and how pre-training with masked language modeling and next sentence prediction enables tasks like text classification, named entity recognition, and extractive question answering.

Explore GPT, a decoder-only, unidirectional transformer that generates coherent text via causal language modeling and pre-training on vast data, with variants like GPT-1 to GPT-4 and Codex.

Explore T5, a text-to-text transfer transformer that unifies bidirectional understanding with autoregressive text generation. Learn its encoder-decoder design, pre-training on C4, and text-to-text tasks like translation, summarization, and question answering.

Explore the practical building blocks of transformers, including embeddings, attention, and pre-trained models, then build a semantic search index to retrieve relevant news paragraphs.

Explore how tokenizers convert text into tokens for BERT-like models, including subword tokenization, token IDs, vocabularies, attention masks, and padding.

Learn how tokenization creates embeddings from word tokens in a transformer. Compare the last hidden state and the polar output, and use cosine distance to measure word similarity across sentences.

Learn how masked language modeling, the pre-training objective for transformers like Bert, uses masks, tokenization, and logits to predict missing words via softmax probabilities, with future work on semantic search.

Build a semantic search engine with transformer-based embeddings to retrieve relevant news articles from a multi news dataset using sentence transformers, cosine similarity, and top-k retrieval.

Demonstrates using BERT, an encoder-only model, for extractive question answering on the SQuAD dataset, predicting start/end tokens, handling no-answer cases, and sliding-window chunking for long contexts.

Fine-tune a decoder-only GPT-2 to follow instructions using the open instruct dataset and Diablo GPT, exploring open-source models like LLaMA and Mistral.

Train from scratch an encoder-decoder t5 to generate product reviews from a product title and the star rating, using a stratified Amazon electronics dataset and a text-to-text formulation.

Discover how large language models leverage decoder-only transformers, scale to billions of parameters, and are trained to understand and generate text, with practical guidance for effective deployment and use.

Explore how RLHF trains conversational LLMs by ranking multiple model responses with human feedback, refining outputs from pre-trained causal language models through iterative fine-tuning.

Explore how decoder-only language models process conversations as a single sequence using chat templates and cues, and how fine-tuning teaches autoregressive responses within contextual multi-turn interactions.

Explore how chat templates and tokenizers structure multi-turn conversations for LLMs, detailing user and assistant roles, message turns, and generation prompts across models like Blenderbot, Mistral, Gemma, and Llama three.

Choose the right large language model by weighing model family, parameter size, instruction following, and context length on the Hugging Face hub, using access tokens for licensed models.

Explore how to use Tiny Llama, load a tokenizer, apply a chat template, and control generation with max tokens, temperature, and top p within the 2048-token context—while noting potential hallucinations.

Dissect how sequence length governs fine tuning of large language models, from hardware and memory during training and inference to the impact of truncation and context.

Build intuition about sequence lengths by tokenizing text and comparing input IDs, tokens, and attention masks across llama3, bert, and mistral.

Discover how numerical precision governs training and deployment of large language models, balancing memory, speed, and accuracy across 32-bit, 16-bit, bf16, and eight bit and four bit formats.

Explore GPU options for LM training, comparing Colab, Ramport, Vessi, Lambda Labs, Google Cloud, and AWS to balance features and cost.

Set up a gpu-enabled linux environment with an rtx 4090, install miniconda, and create a train conda environment to start basic llms training.

Configure axolotl training via a dot yaml file, selecting tiny llama as the base model, specifying llama architecture and tokenizer, and formatting the dataset for input-output learning.

Practice fundamentals by training a tiny language model from a configured script, watching tokenization, decreasing loss, and saving a Tiny Llama model for quick testing on GPUs.

Navigate practical limits of training large language models by exploring llama 3.1 8B, diagnosing memory constraints, and deploying smarter techniques to train with limited resources.

Explore parameter-efficient fine-tuning with LoRa, reducing memory use while preserving accuracy for large language models by inserting trainable low-rank matrices and carefully tuning rank, alpha, and dropout.

Learn how batch size and sequence length drive data memory usage in training large language models, and how to balance memory constraints, epochs, and gradient updates for efficient learning.

Master gradient accumulation and gradient checkpointing to train with larger effective batch sizes while saving memory, by micro-batching, saving selective activations, and balancing training speed with accuracy.

Explore practical LoRA for large models by tuning rank, alpha, dropout, and using gradient accumulation and checkpointing to fit an 8b llama 3 with memory-efficient adapter fine-tuning.

Merge the 1% adapter into the base model with Xolotl and test the resulting model. Address mistakes, add a system prompt, optimize batch size, and reduce losses for larger models.