By the end of this course, you will be able to:
-
Build and deploy a working chatbot using Streamlit, applying transformer concepts and text generation methods
-
Apply prompt engineering techniques (zero-shot, few-shot, system prompts) to control LLM behavior without retraining
-
Construct retrieval-augmented generation (RAG) pipelines using vector search, embeddings, and chunking strategies
-
Design agents that use tools, execute code, and operate across multiple steps with appropriate guardrails
-
Apply classical computer vision techniques — filtering, feature extraction, and segmentation — using OpenCV
-
Train and apply convolutional neural networks (CNNs) for image classification using PyTorch
Section A: AI Engineering
Session 1 — Intro to LLMs
Large language models are built on the transformer architecture, which underpins how modern AI systems process and generate text. This session covers the mechanics of that architecture alongside a first hands-on build using Streamlit.
- Statistical language models and how LLMs differ
- Transformer architecture and attention mechanisms
- Tokenization and text generation basics
- Intro to Streamlit for AI prototyping
Session 2 — LLM Training and First Chatbot
Participants train their first LLM and immediately apply it by building a working chatbot. The session connects training mechanics to practical deployment patterns.
- LLM training pipeline and loss functions
- Fine-tuning vs. inference-only approaches
- Text generation methods and sampling strategies
- Building and deploying a first chatbot
Session 3 — Zero-Shot, Few-Shot, and Prompt Engineering
This session covers how to control LLM behavior without retraining, using learning strategies and prompt design. Participants leave with practical techniques for both.
- Zero-shot and few-shot learning strategies
- Dynamic few-shot selection
- System prompt construction
- Multimodal prompt design
Session 4 — Context Engineering and RAG
Retrieval-augmented generation extends what an LLM can answer by grounding responses in external data. This session builds the core RAG pipeline from retrieval through generation.
- Why context engineering matters for production LLMs
- Vector search and embedding basics
- RAG pipeline construction
- Chunking and retrieval tuning
Session 5 — Advanced RAG and Intro to Agents
Participants extend their RAG pipeline with advanced retrieval patterns, then cross into agentic design. The session ends with a first working agent.
- Advanced retrieval patterns (re-ranking, hybrid search)
- What makes a system agentic
- Agent components: tools, memory, and reasoning loops
- Building a first agent
Session 6 — Advanced Agents and Workshop
This session goes deeper on agent architecture before shifting to applied practice. Participants build their own agent and workshop real use cases from their own work context.
- Code execution agents
- Tool use and multi-step reasoning
- Agent failure modes and guardrails
- Workplace use case identification and group share-out
Section B: Computer Vision
Session 7 — Intro to CV and Image Processing
The second section opens with a survey of computer vision as a field, then moves immediately into image processing fundamentals. Participants apply filtering techniques to a real dataset.
- CV problem types: classification, detection, segmentation
- Classical vs. deep learning approaches
- Image filtering and convolution basics
- Applying processing techniques in Python
Session 8 — Feature Extraction and Object Detection
Participants learn how to represent image content numerically, then use those representations for detection and tracking. OpenCV is the primary tool throughout.
- Feature extraction methods and descriptors
- Histogram-based representation
- Object detection fundamentals
- Video tracking with OpenCV
Session 9 — Image Segmentation
Segmentation breaks an image into meaningful regions rather than just detecting objects. This session covers both thresholding-based and region-based approaches with hands-on practice.
- Thresholding techniques
- Region-based segmentation
- Segmentation vs. detection tradeoffs
- Segmenting images with OpenCV
Session 10 — Deep Learning Fundamentals and PyTorch
This session introduces deep learning from the ground up using PyTorch. Participants build and train a simple neural network before moving to more complex architectures next session.
- Deep learning concepts and terminology
- PyTorch tensors, layers, and training loops
- Loss functions and backpropagation
- Building a simple neural network
Session 11 — CNNs and Final Demos
Convolutional neural networks are the backbone of most computer vision systems. Participants build and train a CNN for image classification, then close with peer demonstrations.
- CNN architecture and convolutional layers
- Pooling, dropout, and regularization
- Training a CNN for image classification
- Peer demos and open discussion
Prototyping AI Essentials is built for engineers, software developers, data engineers, and other technical professionals who are comfortable in Python and ready to build their first working AI systems. Participants should arrive comfortable with Python data tooling (pandas, NumPy, Jupyter notebooks) and have basic data engineering experience.
The course assumes no prior experience building generative AI or computer vision systems — "Essentials" reflects the audience's starting point with AI specifically, not their starting point as engineers. It is designed for technical practitioners ready to move from using AI tools to building them: engineers in aerospace, financial services, manufacturing, software, and other technical and regulated industries who need to ship working AI components in their own environments. Teams evaluating AI vendors, building data products, or designing internal AI tooling will find the technical depth and practical framing directly applicable to their work.
| Course |
Duration |
Live Online (via Zoom) |
Prototyping AI Essentials 1.0
|
16.5 Hours
|
On the following Thursdays:
June 4, 11, 18, 25
July 2, 9, 16, 23, 30
August 6, 13, 2026
2:00 PM - 3:30 PM Pacific Time
|
Who is this course designed for?
This course is designed for technical professionals — engineers, software developers, data engineers, and similar roles — who are comfortable writing Python and ready to build their first working AI systems. It is not introductory programming; it is introductory in the sense that participants are not expected to have prior experience building generative AI or computer vision systems specifically.
What are the prerequisites?
Participants should be comfortable writing and reading Python, familiar with Python data tooling such as pandas, NumPy, and Jupyter notebooks, and have basic data engineering experience. No prior AI or machine learning experience is required.
Do I need prior experience with generative AI or computer vision?
No. The course covers both domains from foundations forward, with the assumption that participants are technically capable but new to building AI systems specifically.
What tools and frameworks will we work with?
Participants work in Python throughout, using Streamlit for prototype interfaces, OpenCV for image processing, PyTorch for deep learning, and vector database platforms for retrieval-augmented generation. The course covers techniques for working with both API-based (closed-source) and open-weights large language models.
What will I build?
Participants build working components across both arcs of the course, including RAG-based chatbots, knowledge retrieval systems, agent workflows, image classifiers, and object detection pipelines. The emphasis throughout is on code participants can adapt and carry back into their own projects.
How does this course apply to my industry?
The course is designed to build patterns that are directly portable across technical and regulated industries. Applied examples draw from aerospace manufacturing, financial services, and similar domains where engineers need to ship working AI components in their own environments.
What is the schedule?
The course meets Thursdays from 2:00 to 3:30 PM Pacific Time across 11 sessions, running June 4 through August 13, 2026. Total duration is 16.5 hours of live, instructor-led instruction.
Will I receive a certificate?
Yes. Participants who complete the course receive a Caltech CTME Certificate of Completion. CEUs are also available.
How does this course relate to the five-day Prototyping AI program?
This public version delivers the technical core of the corporate Prototyping AI program in a paced 11-session format suitable for engineers balancing the course alongside their existing work. Organizations seeking a customized program with adjusted scope, timeline, or topical emphasis should contact CTME to discuss the corporate option.
