Generative AI Agentic AI ML DL with Python

• Machine Learning Fundamentals
• What Is Machine Learning?
• AI / Machine Learning / Data Science
• Machine Learning Playground
• YouTube Recommendation Engine
• Types of Machine Learning
• Machine Learning — Round 2
• Machine Learning Framework
• 6-Step Machine Learning Framework
• Types of Machine Learning Problems
• Types of Data
• Types of Evaluation
• Features in Data
• Splitting Data
• Picking the Model
• Model Tuning
• Model Comparison
• Overfitting and Underfitting
• Experimentation
• Tools Used
• Elements of AI
• Python/Conda/Jupyter Environment
• Introduction to Conda
• Conda environments
• Windows environment setup
• Linux environment setup
• Mac environment setup
• Sharing Conda environments
• Jupyter Notebook
• Downloading workbooks and assignments
• 3. Pandas
• Pandas introduction
• Series
• DataFrames
• CSV files
• Reading data from URLs
• Describing data
• Selecting and viewing data
• Manipulating data
• Assignments

• 4. NumPy
• NumPy introduction
• NumPy data types and attributes
• Creating arrays
• Random seed
• Arrays and matrices
• Array manipulation
• Standard deviation
• Variance
• Reshape
• Transpose
• Dot product
• Element-wise operations
• Comparison operators
• Sorting arrays
• Images as NumPy arrays
• NumPy practice assignment
• Matplotlib & Visualization
• Matplotlib introduction
• Importing and using Matplotlib
• Anatomy of a Matplotlib figure
• Scatter plots
• Bar plots
• Histograms
• Subplots
• Visualization tips
• Plotting Pandas DataFrames
• Regular expressions
• Customizing plots
• Saving and sharing plots
• 6. Scikit-learn & Machine Learning Workflow
• Scikit-learn introduction
• ML refresher
• Scikit-learn cheatsheet
• Typical Scikit-learn workflow
• Train/test splitting
• Data cleaning
• Data transformation
• Data reduction
• Converting data to numbers
• Missing-value handling
• Feature scaling

• Choosing the right model
• Regression
• Classification
• Decision trees
• Fitting models
• Making predictions
• predict() vs predict_proba()
• 7. Model Evaluation
• Cross-validation
• Accuracy
• ROC curve
• ROC-AUC
• Confusion matrix
• Classification report
• R²
• MAE
• MSE
• Model evaluation
• Cross-validation with scoring parameters
• Scikit-learn evaluation functions
• Correlation analysis
• 8. Model Improvement
• Improving ML models
• Hyperparameter tuning
• Metric comparison
• Saving and loading models
• Complete ML workflow
• Scikit-learn practice
• 9. Machine Learning Projects
• Project environment setup
• Framework setup
• Data exploration
• Finding patterns
• Data preparation
• Choosing models
• Experimentation
• Model tuning
• Hyperparameter tuning
• Model evaluation
• Feature importance
• Feature engineering
• Numerical missing values
• Categorical missing values
• RandomizedSearchCV
• Preprocessing
• Making predictions

Deep Learning

• Deep Learning with TensorFlow
• Google Colab
• GPU usage
• TensorFlow 2
• Loading data labels
• Image preparation
• Converting labels into numbers
• Validation sets
• Image preprocessing
• Batching
• Data visualization
• Inputs and outputs
• How machines learn
• Building a deep learning model
• Model summary
• Model evaluation
• Overfitting prevention
• Training neural networks
• TensorBoard
• Making predictions
• Transforming predictions to text
• Visualizing predictions
• Saving/loading trained models
• Training on full dataset
• Test-image predictions
• Kaggle submission
• Predictions on custom images
• Completing Dog Vision project
• Python
• Python Intro
• Python Get Started
• Python Syntax
• Python Comments
• Python Variables
• Python Data Types
• Python Numbers
• Python Casting
• Modify Strings
• Concatenate Strings
• Escape Characters
• String Methods
• String Exercises
• Python Booleans
• Python Operators
• Python Lists
• Python Tuples
• Python Sets
• Python Dictionaries
• Input Functions
• Python If…Else
• if elif
• Python While Loops
• Nested While
• Coffee machine project
• Python For Loops
• Patterns program
• For else
• Arrays
• Implicit conversion
• Explicit Conversion
• Numpy
• Deep Copy
• Shallow Copy
• Different Arrays in Numpy
• Multi-Dimensional Array
• Conversion 1D array to multi D array
• Array Multiplication
• Matrix Multiplication
• Replacing the values in the array
• Replacing the values in the matrix
• User Defined Functions
• Types of Arguments
• Kwargs
• Scope of a variable
• Fibonacci
• Even and Odd count
• Factorial of a number
• Recursion
• Factorial using recursion
• Lambda functions or Lambda
• expression
• filter
• map
• reduce
• Decorators
• Functions
• Special Variable Name
• OOPS
• Constructors
• Class or Static Variables
• Instance variables
• Class Methods
• Instance Methods
• Accessors
• Mutators
• Static Methods
• Namespace
• Nested Class
• Inheritance
• Single Level
• Multilevel
• Multiple
• Method Resolution Order
• Polymorphism
• Duck Typing
• Operator Overloading
• Method Overloading
• Method Over Riding
• Abstraction
• Iterators
• Generators
• Errors
• Handling Exceptions
• finally

Generative AI

• Running Your First LLM Locally with Ollama and Open Source Models
• Your Path to Becoming a Proficient AI Engineer
• Setting Up Your LLM Development Environment with Cursor and UV
• Setting Up Your PC Development Environment with Git and Cursor
• Installing Git, Cloning the Repo, and Cursor IDE
• Installing UV and Setting Up Your Cursor Development Environment
• Setting Up Your OpenAI API Key and Environment Variables
• Installing Cursor Extensions and Setting Up Your Jupyter Notebook
• Running Your First OpenAI API Call and System vs User Prompts
• Building a Website Summarizer with OpenAI Chat Completions API
• Hands-On Exercise: Building Your First OpenAI API Call from Scratch
• LLM Engineering Building Blocks: Models, Tools & Techniques
• Journey: From Chat Completions API to LLM Engineer
• Frontier Models: OpenAI GPT, Claude, Gemini & Grok Compared
• Open-Source LLMs: LLaMA, Mistral, DeepSeek, and Ollama
• Chat Completions API: HTTP Endpoints vs OpenAI Python Client
• Using the OpenAI Python Client with Multiple LLM Providers
• Running Ollama Locally with OpenAI-Compatible Endpoints
• Base, Chat, and Reasoning Models: Understanding LLM Types
• Frontier Models: GPT, Claude, Gemini & Their Strengths and Pitfalls
• Testing ChatGPT-5 and Frontier LLMs Through the Web UI
• Testing Claude, Gemini, Grok & DeepSeek with ChatGPT Deep Research
• Agentic AI in Action: Deep Research, Claude Code, and Agent Mode
• Frontier Models Showdown: Building an LLM Competition Game
• Understanding Transformers: The Architecture Behind GPT and LLMs
• From LSTMs to Transformers: Attention, Emergent Intelligence & Agentic A
• Parameters: From Millions to Trillions in GPT, LLaMA & DeepSeek
• What Are Tokens? From Characters to GPT’s Tokenizer
• Understanding Tokenization: How GPT Breaks Down Text into Tokens
• Tokenizing with tiktoken and Understanding the Illusion of Memory
• Context Windows, API Costs, and Token Limits in LLMs
• Building a Sales Brochure Generator with OpenAI Chat Completions API
• Building JSON Prompts and Using OpenAI’s Chat Completions API
• Chaining GPT Calls: Building an AI Company Brochure Generator
• Building a Brochure Generator with GPT-4 and Streaming Results
• Business Applications, Challenges & Building Your AI Tutor
• Connecting to Multiple Frontier Models with APIs (OpenAI, Claude, Gemini
• Testing GPT-5 Models with Reasoning Effort and Scaling Puzzles
• Testing Claude, GPT-5, Gemini & DeepSeek on Brain Teasers
• Local Models with Ollama, Native APIs, and OpenRouter Integration
• LangChain vs LiteLLM: Choosing the Right LLM Framework
• LLM vs LLM: Building Multi-Model Conversations with OpenAI & Claude
• Building Data Science UIs with Gradio (No Front-End Skills Required)
• Building Your First Gradio Interface with Callbacks and Sharing
• Building Gradio Interfaces with Authentication and GPT Integration
• Markdown Responses and Streaming with Gradio and OpenAI
• Building Multi-Model Gradio UIs with GPT and Claude Streaming
• Building Chat UIs with Gradio: Your First Conversational AI Assistant
• Building a Streaming Chatbot with Gradio and OpenAI API
• System Prompts, Multi-Shot Prompting, and Your First Look at RAG
• How LLM Tool Calling Really Works (No Magic, Just Prompts)
• Common Use Cases for LLM Tools and Agentic AI Workflows
• Building an Airline AI Assistant with Tool Calling in OpenAI and Gradio
• Handling Multiple Tool Calls with OpenAI and Gradio
• Building Tool Calling with SQLite Database Integration
• Introduction to Agentic AI and Building Multi-Tool Workflows
• How Gradio Works: Building Web UIs from Python Code
• Building Multi-Modal Apps with DALL-E 3, Text-to-Speech, and Gradio Bloc
• Running Your Multimodal AI Assistant with Gradio and Tools
• Extra – Compare Frontier LLMs with OpenRouter: Generate SVG Art in Python
• Introduction to Hugging Face Platform: Models, Datasets, and Spaces
• HuggingFace Libraries: Transformers, Datasets, and Hub Explained
• Introduction to Google Colab and Cloud GPUs for AI Development
• Getting Started with Google Colab: Setup, Runtime, and Free GPU Access
• Setting Up Google Colab with Hugging Face and Running Your First Model
• Running Stable Diffusion and FLUX on Google Colab GPUs
• Introduction to Hugging Face Pipelines for Quick AI Inference
• HuggingFace Pipelines API for Sentiment Analysis on Colab T4 GPU
• Named Entity Recognition, Q&A, and Hugging Face Pipeline Tasks
• Hugging Face Pipelines: Image, Audio & Diffusion Models in Colab
• Tokenizers: How LLMs Convert Text to Numbers
• Tokenizers in Action: Encoding and Decoding with Llama 3.1
• How Chat Templates Work: LLaMA Tokenizers and Special Tokens
• Comparing Tokenizers: Phi-4, DeepSeek, and QWENCoder in Action
• Deep Dive into Transformers, Quantization, and Neural Networks
• Working with Hugging Face Transformers Low-Level API and Quantization
• Inside LLaMA: PyTorch Model Architecture and Token Embeddings
• Inside LLaMA: Decoder Layers, Attention, and Why Non-Linearity Matters
• Running Open Source LLMs: Phi, Gemma, Qwen & DeepSeek with Hugging Face
• Visualizing Token-by-Token Inference in GPT Models
• Building Meeting Minutes from Audio with Whisper and Google Colab
• Building Meeting Minutes with OpenAI Whisper and LLaMA 3.2
• Wrap-Up: Build a Synthetic Data Generator with Open Source Models
• Choosing the Right LLM: Model Selection Strategy and Basics
• The Chinchilla Scaling Law: Parameters, Training Data and Why It Matters
• Understanding AI Model Benchmarks: GPQA, MMLU-Pro, and HLE
• Limitations of AI Benchmarks: Data Contamination and Overfitting
• Build a Connect Four Leaderboard (Reasoning Benchmark)
• Navigating AI Leaderboards: Artificial Analysis, HuggingFace & More
• Artificial Analysis Deep Dive: Model Intelligence vs Cost Comparison
• Vellum, SEAL, and LiveBench: Essential AI Model Leaderboards
• LM Arena: Blind Testing AI Models with Community Elo Ratings
• Commercial Use Cases: Automation, Augmentation & Agentic AI
• Selecting LLMs for Code Generation: Python to C++ with Cursor
• Selecting Frontier Models: GPT-5, Claude, Grok & Gemini for C++ Code Gen
• Porting Python to C++ with GPT-5: 230x Performance Speedup
• AI Coding Showdown: GPT-5 vs Claude vs Gemini vs Groq Performance
• Open Source Models for Code Generation: Qwen, DeepSeek & Ollama
• Building a Gradio UI to Test Python-to-C++ Code Conversion Models
• Qwen 3 Coder vs GPT OSS: OpenRouter Model Performance Showdown
• Model Evaluation: Technical Metrics vs Business Outcomes
• Python to Rust Code Translation: Testing Gemini 2.5 Pro with Cursor
• Porting Python to Rust: Testing GPT, Claude, and Qwen Models
• Open Source Model Wins? Rust Code Generation Speed Challenge

RAG and Agentic AI

• Introduction to RAG: Retrieval Augmented Generation Fundamentals
• Building a Simple RAG Knowledge Assistant with GPT-4-1 Nano
• Building a Simple RAG System: Dictionary Lookup and Context Retrieval
• Vector Embeddings and Encoder LLMs: The Foundation of RAG
• How Vector Embeddings Represent Meaning: From word2vec to Encoders
• Understanding the Big Idea Behind RAG and Vector Data Stores
• Vectors for RAG: Introduction to LangChain and Vector Databases
• Breaking Documents into Chunks with LangChain Text Splitters
• Encoder Models vs Vector Databases: OpenAI, BERT, Chroma & FAISS
• Creating Vector Stores with Chroma and Visualizing Embeddings with t-SNE
• 3D Vector Visualizations and Comparing Embedding Models
• Building a Complete RAG Pipeline with LangChain and Chroma
• Building a RAG Pipeline with LangChain: LLM & Retriever Setup
• Building RAG with LangChain: Retriever and LLM Integration
• Building Production RAG with Python Modules and Gradio UI
• RAG with Conversation History: Building a Gradio UI and Debugging Chunki
• RAG Evaluations: Measuring Performance and Iterating on Your Pipeline
• Evaluating RAG Systems: Retrieval Metrics, LLM as Judge, and Golden Data
• Evaluating RAG Systems: MRR, NDCG, and Test Data with Pydantic
• LLM as a Judge: Evaluating RAG Answers with Structured Outputs
• Running RAG Evaluations with Gradio: MRR, nDCG, and Test Results
• Experimenting with Chunking Strategies and Embedding Models in RAG
• Testing OpenAI Embeddings and Evaluating RAG Performance Gains
• Advanced RAG Techniques: Pre-processing, Re-ranking & Evals
• Advanced RAG Techniques: Chunking, Encoders, and Query Rewriting
• Advanced RAG Techniques: Query Expansion, Re-ranking & GraphRAG
• Building Advanced RAG Without LangChain: Semantic Chunking with LLMs
• Creating Embeddings with Chroma, Visualizing with t-SNE, and Re-ranking
• Building RAG Without LangChain: Re-ranking and Query Rewriting
• Building Production RAG with Query Expansion and Multiprocessing
• Advanced RAG Evaluation: From 0.73 to 0.91 MRR with GPT-4o
• RAG Challenge: Beat My Results & Build Your Knowledge Worker
• Training, Datasets, and Generalization: Your Capstone Begins
• Finetuning LLMs & The Price is Right Capstone Project Intro
• Curating Datasets: Finding Data Sources and Building Training Sets
• Curating Amazon Data with Hugging Face for Price Prediction
• Exploring Amazon Dataset Distribution and Removing Duplicates
• Weighted Sampling with NumPy and Uploading Datasets to Hugging Face
• Five-Step Strategy for Selecting and Applying LLMs to Business Problems
• The Five-Step AI Process & Productionizing with MLOps
• Data Pre-processing with LLMs and Groq Batch Mode
• Batch Processing with Groq API and JSONL Files for LLM Workflows
• Batch Processing with Groq: Running 22K LLM Requests for Under $1
• Building Baseline Models with Traditional ML and XGBoost
• Building Your First Baseline with Random Pricer and Scikit-learn
• Baseline Models and Linear Regression with Scikit-Learn
• Bag of Words and CountVectorizer for Linear Regression NLP
• Random Forest and XGBoost: Ensemble Models in Scikit-Learn
• Training Your First Neural Network and Testing Frontier Models
• Human Baseline Performance vs Machine Learning Models in PyTorch
• Building Your First Neural Network with PyTorch
• Testing GPT-4o-mini and Claude Opus Against Neural Networks
• Testing Gemini 3, GPT-5.1, Claude 4.5 & Grok on Price Prediction
• Fine-Tuning OpenAI Frontier Models with Supervised Fine-Tuning
• Fine-Tuning GPT-4o Nano with OpenAI’s API for Custom Models
• Fine-Tuning GPT-4o-mini-nano: Running Jobs and Monitoring Training
• Fine-Tuning Results: When GPT-4o-mini Gets Worse, Not Better
• When Fine-Tuning Frontier Models Fails & Building Deep Neural Networks
• Deep Neural Network Redemption: 289M Parameters vs Frontier Models
• Introduction to QLoRA for Fine-Tuning Open-Source Models
• LoRA: Training LLaMA 3.2 with Low-Rank Adapters
• LoRA Hyperparameters and QLoRA Quantization Explained
• Setting Up Google Colab and Exploring LLaMA 3.2 Model Architecture
• Loading Models with 8-bit and 4-bit Quantization Using QLoRA
• LoRA Parameter Calculations and Model Size on Hugging Face
• Preparing Your Dataset for Fine-Tuning with Token Limits
• Fine-Tuning Data Prep: Rounding Prices and Token Length Optimization
• Preparing Hugging Face Datasets and Testing Base LLaMA 3.2 Model
• Base Models vs Chat Models: Understanding LLaMA Fine-Tuning
• Fine-Tuning Hyperparameters: QLoRA Settings and Training Config
• Learning Rate, Optimizers, and Training Hyperparameters for LoRA
• Setting Up Training: Hyperparameters, qLoRA Config & Weights & Biases
• Setting Up Weights & Biases and the HuggingFace SFT Trainer
• Running Fine-Tuning with TRL and Monitoring Training in Weights & Biases
• Monitoring Your Fine-Tuning Run with Weights & Biases
• Full Dataset Training on Google Colab A100 with 800K Data Points
• Monitoring Training Loss and Learning Rate in Weights & Biases
• Analyzing Weights & Biases Results and Catching Overfitting
• Managing Runs in Weights & Biases and Selecting Best Model Checkpoints
• Results Day: Running Inference on Fine-Tuned Models & Loss Calculation D
• Cross-Entropy Loss: How LLMs Calculate Probability Distributions
• Testing Our Fine-Tuned LoRA Model Against GPT-4o Nano
• Fine-Tuned LLaMA 3.2 Crushes GPT-5.1 and Frontier Models
• Intro to Agentic AI & Serverless Deployment on Modal
• Designing Agent Architectures & Modal Platform Setup
• Running Python Locally and in the Cloud with Modal Remote Execution
• Setting Up Modal Secrets and Deploying LLaMA Models to the Cloud
• Deploying Fine-Tuned Models to Modal Cloud with Persistent Storage
• Building Your First Agent with Modal Serverless AI
• Building Advanced RAG with ChromaDB and Vector Stores (No LangChain)
• Visualizing Chroma Vectors with t-SNE and Building a RAG Pipeline
• RAG with GPT-4o vs Fine-Tuned Models: Building an Ensemble
• Ensemble Model Success: Combining RAG, Neural Networks & Modal
• Building and Testing an Ensemble Agent with Multiple LLM Calls
• Structured Outputs with Pydantic and Constrained Decoding
• Building a Deal Scanner with Structured Outputs and Pydantic
• Structured Outputs for Parsing & Building a Pushover Notification Agent
• Building Agentic AI: Planning Agents with Tool Orchestration
• Building an Autonomous Planner Agent with Tool Calling and GPT-4
• Building an Autonomous Multi-Agent System with Tool Calling and Agent Lo
• Building a Multi-Model AI Platform: 34 Calls Across GPT-5, Claude & Open
• Finalizing Your Agentic Workflow and Becoming an AI Engineer
• Building the Price-Is-Right Agent UI with Gradio and DealAgentFramework