Summer of Code 2026
Curriculum Plan
At a Glance
| Days | Module | Focus |
|---|---|---|
| Week 1, Day 1 | Intro | AI concepts survey, types of AI, setting the stage |
| Week 1, Days 2–3 | Module 1: Working with Data | pandas, matplotlib, scikit-learn, Mongolian datasets |
| Week 1, Days 4–5 | Module 2: Physical Computing | micro:bit V2, CreateAI, gesture ML models, MakeCode |
| Week 2, Days 6–7 | Module 3: Computer Vision | Neural networks, CNNs, 5 CV algorithms, mini-projects |
| Week 2, Days 8–9 | Module 4: Generative AI | OpenAI SDK, word embeddings, image generation, VLMs |
| Week 2, Day 10 | Capstone | Final project build and optional show & share |
Day 1 — Week 1 — Intro
Welcome to the Future Intelligence Lab!
Learning Objectives
- Articulate what AI is and name 3+ real-world examples they interact with daily
- Distinguish between supervised ML, computer vision, and generative AI
- Preview all four modules and understand how the two weeks connect
- Run a Jupyter K-12 notebook and interact with all three types of AI hands-on
Session Schedule (2 hours)
| Segment | Details | Time | Notes |
|---|---|---|---|
| Instructor Intro (5 min) | “Who am I?” — instructor background and motivation. Sets the tone for the two weeks. | 0:00–0:05 | Warm and personal |
| What is AI? (20 min) | Slides: definition (learning from examples vs. following rules), why AI is having its moment now (data + compute + algorithms), and what AI is NOT (not magic, not conscious, not always right, not one thing). | 0:05–0:25 | Dispel myths early |
| “Does It Use AI?” (15 min) | Class vote on 7 tech examples (ChatGPT, Fitness Tracker, Calculator, Washing Machine, Music App, Smartphone Camera, Video Game) — show of hands. Instructor reveals and explains each, including the “maybe” cases. | 0:25–0:40 | Encourage debate on edge cases |
| AI Around You (10 min) | Students add their own examples to a Miro board with three pre-labeled zones: No / Maybe / Yes. Reinforces the classification before the deep-dive. | 0:40–0:50 | Miro board set up in advance |
| Types of AI (20 min) | Detailed slides: supervised ML (regression and classification with forward references to Days 2–5), computer vision (pixels → CNNs → applications), generative AI (LLMs and diffusion models). Ends with the two-week journey map. | 0:50–1:10 | Keep pace brisk |
| Introducing Notebooks (10 min) | What a notebook is, anatomy of a Jupyter notebook cell, intro to Jupyter-K12 — the platform students will use throughout the course. | 1:10–1:20 | Demo platform live |
| Hello World + API Key Setup (25 min) | Instructor demos the Hello World notebook live, then students open it and run each cell themselves. Distribute and enter OpenRouter API keys — students paste their key into the Jupyter-K12 environment settings (Settings → scan QR code). | 1:20–1:45 | Pair struggling students |
| AI in Action Notebook (10 min) | Students open the AI in Action notebook and work through three sections: spam detector (Supervised ML), live webcam object detection (Computer Vision), and generative Q&A (Generative AI). | 1:45–1:55 | Requires API key from previous step |
| Discussion & Wrap-Up (5 min) | What worked? What didn’t? Preview: tomorrow we dig into a real Mongolian air quality dataset with pandas. | 1:55–2:00 |
Resources & Tools
- Miro board with three pre-labeled zones (No / Maybe / Yes)
- Jupyter-K12 platform (jupyter-k12.org)
- Hello World notebook (
labs/01/notebooks/hello_world.ipynb) - AI in Action notebook (
labs/01/notebooks/ai_in_action.ipynb) - OpenRouter API keys (one per student, distributed before class)
Day 2 — Week 1 — Module 1: Working with Data
Working With Data
Learning Objectives
- Load and inspect a CSV dataset using pandas (
.head(),.describe(),.info()) - Create line charts, bar charts, and scatter plots with matplotlib
- Investigate a real-world dataset to identify patterns and anomalies
- Calculate and interpret a correlation coefficient
Session Schedule (2 hours)
| Segment | Details | Time | Notes |
|---|---|---|---|
| Recap (5 min) | Quick review: types of AI, notebooks, AI in Action. | 0:00–0:05 | |
| Start With Data (10 min) | Slides: why AI starts with data. Spam filters, music recommendations, ChatGPT — all trained on labelled examples. More data + better data = smarter model. | 0:05–0:15 | Frame data as the foundation |
| Introducing Pandas (15 min) | Slides: what pandas is, brief history (Wes McKinney, 2008), key concepts — DataFrame, Series, reading CSVs. | 0:15–0:30 | |
| Pandas Demo + Hands-On (10 min) | Instructor demos the pandas notebook live, then students run it themselves. | 0:30–0:40 | labs/02/notebooks/pandas.ipynb |
| Introducing Matplotlib (15 min) | Slides: what matplotlib is, brief history (John D. Hunter, 2003), key concepts — Figure, Axes. Usually paired with pandas. | 0:40–0:55 | |
| Matplotlib Demo + Hands-On (10 min) | Instructor demos the matplotlib notebook live, then students run it themselves. | 0:55–1:05 | labs/02/notebooks/matplotlib.ipynb |
| Ulaanbaatar Air Quality Hook (10 min) | Striking fact: Ulaanbaatar regularly records PM2.5 levels 30–40× the WHO safe limit — worse than Beijing, worse than Delhi. Watch a short video. ‘Your job: figure out why, using pandas and matplotlib.’ | 1:05–1:15 | Show video |
| Air Quality Demo + Hands-On (25 min) | Instructor opens and walks through the Air Quality notebook. Students run it and explore the dataset themselves. Reflection: what did you learn? | 1:15–1:40 | labs/02/notebooks/air_quality.ipynb |
| Introducing Correlation (20 min) | Slides: correlation coefficient (+1, 0, −1), correlation ≠ causation. Demo + hands-on with the Correlation notebook. Reflection: what surprised you? | 1:40–2:00 | labs/02/notebooks/correlation.ipynb |
Resources & Tools
- Jupyter-K12 platform
- Ulaanbaatar AQI dataset (
labs/02/notebooks/ulaanbaatar_aqi_2019_2021.csv) - pandas notebook (
labs/02/notebooks/pandas.ipynb) - matplotlib notebook (
labs/02/notebooks/matplotlib.ipynb) - Air quality notebook (
labs/02/notebooks/air_quality.ipynb) - Correlation notebook (
labs/02/notebooks/correlation.ipynb) - Ulaanbaatar smog video (YouTube)
Day 3 — Week 1 — Module 1: Working with Data
How Machines Learn
Learning Objectives
- Use scikit-learn’s fit/predict pattern to train and apply a machine learning model
- Load and explore a real Mongolian dzud dataset
- Apply linear regression to predict livestock mortality from climate variables
- Explain the difference between training data and test data
Session Schedule (2 hours)
| Segment | Details | Time | Notes |
|---|---|---|---|
| Recap (5 min) | Pandas, Matplotlib, Air Quality investigation, correlation. | 0:00–0:05 | |
| Why Use AI for Data? (5 min) | Transition: we found patterns ourselves yesterday — today we let a machine find them. | 0:05–0:10 | |
| Introducing scikit-learn (20 min) | Slides: what scikit-learn is, the three-step pattern (Prepare → Fit → Predict), regression vs. classification vs. clustering. Demo + hands-on with the sklearn notebook. | 0:10–0:30 | labs/03/notebooks/sklearn.ipynb |
| Dzud Introduction (10 min) | For many Mongolian families, livestock are the primary source of food, income, and identity. A dzud is a catastrophic winter livestock event — in 2001, over 7 million animals died. Watch video. ‘Can we use AI to predict an upcoming dzud?’ | 0:30–0:40 | Show video |
| Finding Disasters (20 min) | Demo + hands-on: students load the dzud dataset and use pandas to identify catastrophic years and aimags most affected. Reflection: what did you discover? | 0:40–1:00 | labs/03/notebooks/finding_disasters.ipynb |
| Finding the Cause (15 min) | Instructor-led walkthrough: which variables correlate most with mortality? Winter temperature and summer drought emerge as the strongest predictors. | 1:00–1:15 | labs/03/notebooks/finding_cause.ipynb |
| Linear Regression Concepts (10 min) | Slides: best-fit line, training vs. test split (80/20), predicting new values. Diagram of a regression line. | 1:15–1:25 | |
| Regression Demo + Hands-On (30 min) | Instructor demos linear regression on the dzud data, then students run and explore the notebook. Reflection: did the model predict what you expected? | 1:25–1:55 | labs/03/notebooks/regression.ipynb |
| Wrap-Up (5 min) | ‘You just trained your first AI model.’ Preview: tomorrow we bring this same idea into the physical world with micro:bits. | 1:55–2:00 |
Resources & Tools
- Jupyter-K12 platform
- scikit-learn notebook (
labs/03/notebooks/sklearn.ipynb) - Dzud dataset (
labs/03/notebooks/mongolia_dzud_1990_2013.csv) - Finding Disasters notebook (
labs/03/notebooks/finding_disasters.ipynb) - Finding the Cause notebook (
labs/03/notebooks/finding_cause.ipynb) - Linear Regression notebook (
labs/03/notebooks/regression.ipynb) - Dzud video (YouTube)
Day 4 — Week 1 — Module 2: Physical Computing
AI in the Physical World
Learning Objectives
- Connect a micro:bit wearable to CreateAI via radio and view live accelerometer data
- Record and train a gesture model with 4–5 action classes
- Test model accuracy and understand why diverse training data matters
- Connect the micro:bit ML workflow to the scikit-learn concepts from Day 3
Session Schedule (2 hours)
| Segment | Details | Time | Notes |
|---|---|---|---|
| Recap (5 min) | scikit-learn, dzud dataset, linear regression. How does training a model in Python relate to today? | 0:00–0:05 | Plant the connection early |
| micro:bit Overview (20 min) | Slides: what a micro:bit is (front and back), what an accelerometer measures (X, Y, Z), the wearable + radio setup that allows wireless movement. Explain the two-device workflow: wearable collects data wirelessly via radio; receiver connects to the laptop. | 0:05–0:25 | Show hardware physically |
| Pair Up & Distribute Hardware (10 min) | Students find a partner. Each pair picks up one wearable micro:bit (with battery) and one radio micro:bit. | 0:25–0:35 | One of each per pair |
| CreateAI Walkthrough (20 min) | Instructor-led: open createai.microbit.org, connect using micro:bit radio, connect the wearable first, then the receiver. Verify that accelerometer graphs move correctly. See step-by-step below. | 0:35–0:55 | Walk through live with class |
| Record Actions (20 min) | Guided: each person records 2 actions (e.g. waving, writing). Partners take turns wearing the wearable. Aim for 4–5 actions total per pair. See step-by-step below. | 0:55–1:15 | Band must be snug |
| Train & Test Model (15 min) | Click “Train model.” Take turns testing each action. Discussion: what worked well? What did it get wrong? | 1:15–1:30 | |
| Diverse Data Discussion (20 min) | Slides: what is diverse data and why it matters. Case studies: facial recognition error rates for darker-skinned women (Joy Buolamwini, 2018), voice assistant struggles with non-standard accents. Hands-on: swap desks with another pair, test their model on your own wrist. | 1:30–1:50 | Key concept — don’t rush |
| Discussion & Wrap-Up (10 min) | What did you find when testing another pair’s model? What would you do differently? Preview: tomorrow you write Python code that responds to detected gestures. | 1:50–2:00 |
CreateAI Connection — Step-by-Step
- Create a project: “My First Project”
- Click “Connect using micro:bit radio instead”
- Connect the wearable (collector) micro:bit and click “Next”; select the connection from the popup
- Disconnect the USB cable, then very gently insert the battery wire — pause until everyone sees the smiley face
- Connect the receiver micro:bit and click “Next”; select the connection from the popup
- Put the wearable on one wrist (it doesn’t matter who goes first — both partners will have a turn)
- Check that the accelerometer graphs are moving — you are connected and ready to record!
Recording Actions — Step-by-Step
- Create an action: “Waving”
- Record and repeat three times
- Pass the wearable to your partner; they record a different action of their choice — make sure the band is tight!
- Pause until everyone has two actions
- Each person records one more action (any action they choose)
- Pause until everyone has four actions total, then continue to free hands-on time
Resources & Tools
- BBC micro:bit V2 (1 wearable + 1 radio receiver per pair) + USB cables + Chrome browser
- createai.microbit.org
Instructor Notes: Disconnect all wearable micro:bits from battery packs at the end of the session — the battery connector is easy to damage.
Day 5 — Week 1 — Module 2: Physical Computing
AI in the Physical World — Coding the Response
Learning Objectives
- Re-connect to CreateAI and verify trained actions are still working
- Write a MakeCode Python program using
ml.on_startevent handlers for each action - Download the trained model + code to the wearable micro:bit
- Design and build a purposeful mini-project (fitness tracker, clapper, safe driving app, or original idea)
Session Schedule (2 hours)
| Segment | Details | Time | Notes |
|---|---|---|---|
| Recap (5 min) | micro:bit wearable, CreateAI, recording actions, diverse data. | 0:00–0:05 | |
| Reconnect & Test Actions (15 min) | Pick up the same micro:bits and same laptop as Day 4. Reconnect to CreateAI using the radio option. Quick test to confirm actions are still recognized. See step-by-step below. | 0:05–0:20 | Saved per machine |
| MakeCode Demo (15 min) | Instructor demo: open the project in MakeCode. Show on_start event handlers — each action triggers a different icon or sound. Demonstrate adding music.play to an action. |
0:20–0:35 | Slides with code snippets |
| MakeCode Hands-On (20 min) | Students code their own on_start handlers for each of their actions. |
0:35–0:55 | |
| Download to micro:bit Demo (10 min) | Instructor demo: click download, follow prompts to disconnect the radio micro:bit and reconnect the wearable for flashing. See step-by-step below. | 0:55–1:05 | |
| Download to micro:bit Hands-On (10 min) | Students flash their own wearable micro:bits with the trained model + code. | 1:05–1:15 | |
| Project Time (35 min) | Students build their mini-project. Options: fitness tracker (count arm raises on LED), clapper (clap to toggle LEDs/sound), safe driving app (detect steering vs. texting), or original idea. | 1:15–1:50 | Float and support |
| Reflect & Share (10 min) | Each group: what did you build? How does it work? | 1:50–2:00 | Celebrate creative use |
Reconnecting to CreateAI — Step-by-Step
- Connect to createai.microbit.org — remember to use the micro:bit radio option
- The wearable micro:bit connects first
- After connecting, do a quick test to confirm all Day 4 actions are still being recognised
- Pause and wait for the whole class to catch up before moving on
Downloading to micro:bit — Step-by-Step
- Click the download button in MakeCode
- Follow the prompts to disconnect the radio micro:bit
- Plug in the wearable micro:bit via USB (you can leave the battery connected)
- Wait for the model to finish downloading
- Disconnect the wearable from USB
- Test your code!
Resources & Tools
- micro:bits from Day 4
- createai.microbit.org + makecode.microbit.org
- Optional: buzzer accessories for audio feedback
Instructor Notes: Module 2 capstone. Accuracy matters less than purposeful design — celebrate a 70% accurate exercise counter more than a 95% accurate wave detector with no clear use. Transition line for tomorrow: ‘Next week we’ll teach computers to see, not just move.’
Day 6 — Week 2 — Module 3: Computer Vision
How Computers See
Learning Objectives
- Explain how a neural network learns using layers, weights, and training examples
- Describe how a CNN processes an image (pixels → features → predictions)
- Run pre-trained face detection, object detection, and pose estimation models in a notebook
- Map pose landmarks to a 3D scene using a custom avatar
Session Schedule (2 hours)
| Segment | Details | Time | Notes |
|---|---|---|---|
| Neural Networks Intro (20 min) | Slides: neural network structure (input layer, hidden layers, output layer, weights). Interactive demo: “Will I Do Well on My Test?” — students adjust inputs and observe the network’s output live. | 0:00–0:20 | In-browser neural network demo |
| Hands-On: Neural Network (10 min) | Students interact with the neural network demo themselves and reflect: did it produce the results you expected? | 0:20–0:30 | |
| Computer Vision Concepts (15 min) | Slides: CV is everywhere (autofocus, self-driving cars, X-ray analysis). How computers see: pixels as numbers, CNNs. Five CV algorithm types: face detection, object detection, pose estimation, gesture recognition, image segmentation. | 0:30–0:45 | |
| Face Detection Demo + Hands-On (15 min) | What is face detection? Bounding boxes, not facial recognition. Demo then students run the notebook. | 0:45–1:00 | labs/06/notebooks/face_detection.ipynb |
| Object Detection Demo + Hands-On (15 min) | Multiple objects, bounding boxes, real-time use cases. Demo then students run the notebook. | 1:00–1:15 | labs/06/notebooks/object_detection.ipynb |
| Pose Estimation Demo + Hands-On (15 min) | Key body landmarks, fitness and gaming applications. Demo then students run the notebook. | 1:15–1:30 | labs/06/notebooks/pose_landmarks.ipynb |
| 3D Pose Avatar Demo + Hands-On (15 min) | Remove the camera view — plot just the joint positions in a live 3D scene. Students try it on themselves. | 1:30–1:45 | labs/06/notebooks/pose_avatar.ipynb |
| Wrap-Up (15 min) | Reflection: did the CV algorithms produce the results you expected? Preview: tomorrow we cover two more CV algorithms and build our own mini-app. | 1:45–2:00 |
Resources & Tools
- Jupyter-K12 platform
- In-browser neural network demo (
labs/components/nn.html) - Face Detection notebook (
labs/06/notebooks/face_detection.ipynb) - Object Detection notebook (
labs/06/notebooks/object_detection.ipynb) - Pose Estimation notebook (
labs/06/notebooks/pose_landmarks.ipynb) - 3D Pose Avatar notebook (
labs/06/notebooks/pose_avatar.ipynb)
Day 7 — Week 2 — Module 3: Computer Vision
Computer Vision — Continued + Mini-Project
Learning Objectives
- Use gesture recognition to detect hand poses and build interactive applications
- Apply image segmentation to label every pixel and remove backgrounds
- Combine any CV algorithm with custom Python logic to create an original mini-app
Session Schedule (2 hours)
| Segment | Details | Time | Notes |
|---|---|---|---|
| Recap (5 min) | Neural networks, CNNs, face detection, object detection, pose estimation, 3D avatar. | 0:00–0:05 | |
| Gesture Recognition Concepts (10 min) | Slides: detecting hand landmarks, 8 gesture categories (closed fist, open palm, victory, etc.), applications — game control, sign language, virtual art. | 0:05–0:15 | |
| Gesture Recognition Demo + Hands-On (20 min) | Demo then students run the gesture recognition notebook. | 0:15–0:35 | labs/07/notebooks/gesture_recognition.ipynb |
| Gesture Painter Demo + Hands-On (20 min) | Use gestures to paint on a canvas. Demo then students try it. | 0:35–0:55 | labs/07/notebooks/gesture_painter.ipynb |
| Rock, Paper, Scissors Demo + Hands-On (15 min) | Play Rock, Paper, Scissors against the computer using hand gestures. | 0:55–1:10 | labs/07/notebooks/rock_paper_scissors.ipynb |
| Image Segmentation Concepts + Demo + Hands-On (20 min) | Slides: labelling every pixel, background removal, virtual wardrobe. Demo then students run the notebook. | 1:10–1:30 | labs/07/notebooks/image_segmentation.ipynb |
| Create Your Own Mini-App (25 min) | Students pick any of the 5 CV algorithms covered over Days 6–7, copy/paste examples, and add their own Python logic to make it original. | 1:30–1:55 | Float and support |
| Wrap-Up (5 min) | Share: what did you build? Preview: tomorrow we start Generative AI — chatbots, music, and 3D scenes. | 1:55–2:00 |
Resources & Tools
- Jupyter-K12 platform
- Gesture Recognition notebook (
labs/07/notebooks/gesture_recognition.ipynb) - Gesture Painter notebook (
labs/07/notebooks/gesture_painter.ipynb) - Rock, Paper, Scissors notebook (
labs/07/notebooks/rock_paper_scissors.ipynb) - Image Segmentation notebook (
labs/07/notebooks/image_segmentation.ipynb)
Day 8 — Week 2 — Module 4: Generative AI
Generative AI — Language Models
Learning Objectives
- Explain how LLMs are built on transformers and word embeddings
- Use gensim/Word2Vec to explore semantic similarity and word analogies
- Call a language model from Python using the OpenAI SDK
- Apply streaming and structured output to build more useful AI-powered programs
Session Schedule (2 hours)
| Segment | Details | Time | Notes |
|---|---|---|---|
| Recap (5 min) | CV algorithms, mini-apps. Bridge: ‘Today we move from computers that see to computers that speak and create.’ | 0:00–0:05 | |
| What is Generative AI? (15 min) | Slides: traditional AI classifies/detects; generative AI creates. LLMs built on neural networks. The transformer breakthrough (2017) — teaches models how words relate across long passages. | 0:05–0:20 | |
| Word Embeddings (20 min) | Slides: converting words to vectors, similar words cluster together. Word2Vec (2013). Demo + hands-on: explore analogies (King − Man + Woman ≈ Queen) in the Word2Vec notebook. | 0:20–0:40 | labs/08/notebooks/word2vec.ipynb |
| Chatting With Models (10 min) | Slides: the OpenAI Python SDK, message roles (system / user / assistant), how the system prompt shapes model behaviour. | 0:40–0:50 | |
| OpenAI SDK Demo + Hands-On (20 min) | Instructor demos the OpenAI SDK notebook. Students run it and experiment with their own system and user prompts. | 0:50–1:10 | labs/08/notebooks/openai_sdk.ipynb |
| Streaming Demo + Hands-On (15 min) | Why wait for the full response? Streaming sends each token as it is generated. Demo + hands-on. | 1:10–1:25 | labs/08/notebooks/openai_streaming.ipynb |
| Structured Output Concepts (10 min) | Problem: plain-text responses are unpredictable. Structured output uses Pydantic to return clean, typed fields the program can use directly. | 1:25–1:35 | |
| Structured Output + Piano & 3D Scenes (25 min) | Demo + hands-on: basic structured output, then applying it to generate a piano melody and a 3D scene. | 1:35–2:00 | labs/08/notebooks/structured_output.ipynb, structured_output_piano.ipynb, structured_output_mesh.ipynb |
Resources & Tools
- Jupyter-K12 platform
- Word2Vec notebook (
labs/08/notebooks/word2vec.ipynb) - OpenAI SDK notebook (
labs/08/notebooks/openai_sdk.ipynb) - Streaming notebook (
labs/08/notebooks/openai_streaming.ipynb) - Structured Output notebook (
labs/08/notebooks/structured_output.ipynb) - Structured Output Piano notebook (
labs/08/notebooks/structured_output_piano.ipynb) - Structured Output Mesh/3D notebook (
labs/08/notebooks/structured_output_mesh.ipynb) - OpenRouter API keys
Day 9 — Week 2 — Module 4: Generative AI
Generative AI — Images and Vision Language Models
Learning Objectives
- Explain how a diffusion model generates an image from text (forward diffusion, denoising)
- Craft effective image-generation prompts using subject, style, lighting, and quality descriptors
- Use image-to-image to transform or restyle an existing photo
- Use a VLM to describe images, answer questions about them, and power an assistive tool
Session Schedule (2 hours)
| Segment | Details | Time | Notes |
|---|---|---|---|
| Recap (5 min) | Word embeddings, OpenAI SDK, streaming, structured output. | 0:00–0:05 | |
| Image Generation Concepts (15 min) | Slides: diffusion models — training adds noise; generation runs in reverse. Text encoder steers the process. Show the denoising animation embedded in the notebook. | 0:05–0:20 | Diffusion steps animation |
| Prompting for Images (5 min) | Prompt scaffold: Subject + Style/Medium + Lighting + Composition + Quality + Technical specs. Examples. | 0:20–0:25 | |
| Image Generation Demo + Hands-On (20 min) | Instructor demo, then students generate their own images and iterate on prompts at least 3 times. Reflection: better or worse than expected? | 0:25–0:45 | labs/09/notebooks/image_generation.ipynb |
| Image-to-Image (20 min) | Slides: restyle an existing image with a text prompt. Demo + hands-on. | 0:45–1:05 | labs/09/notebooks/image_to_image.ipynb |
| VLMs vs. CNNs (10 min) | Slides: CNNs detect objects and landmarks; VLMs produce descriptive language. VLM = visual encoder + language model. Show an impressive demo and a failure case. | 1:05–1:15 | |
| VLM Demo + Hands-On (15 min) | Students query a VLM with their own images. Find one impressive result and one failure. | 1:15–1:30 | labs/09/notebooks/vlm.ipynb |
| VLM Reasoning Demo + Hands-On (15 min) | Ask richer questions: ‘Read the text in the image’, ‘How many people have red shirts?’, ‘Is the person wearing glasses?’ | 1:30–1:45 | labs/09/notebooks/vlm_reasoning.ipynb |
| Assistive VLMs Demo + Hands-On (10 min) | Capture → Describe → Speak: a three-step seeing assistant combining VLM output with text-to-speech. | 1:45–1:55 | labs/09/notebooks/vlm_assistive.ipynb |
| Wrap-Up (5 min) | Preview: tomorrow is the final day — pick any module and build something of your own. | 1:55–2:00 |
Resources & Tools
- Jupyter-K12 platform
- Image Generation notebook (
labs/09/notebooks/image_generation.ipynb) - Image-to-Image notebook (
labs/09/notebooks/image_to_image.ipynb) - VLM notebook (
labs/09/notebooks/vlm.ipynb) - VLM Reasoning notebook (
labs/09/notebooks/vlm_reasoning.ipynb) - Assistive VLM notebook (
labs/09/notebooks/vlm_assistive.ipynb) - OpenRouter API keys
Day 10 — Week 2 — Capstone
Final Project
Learning Objectives
- Synthesize learning across modules by building an original project in Python
- Demonstrate genuine understanding of at least one AI concept through a working program
- Optionally present their project and explain what it does and how it works
Session Schedule (2 hours)
| Segment | Details | Time | Notes |
|---|---|---|---|
| Recap of Two Weeks (10 min) | Instructor overview: pandas and matplotlib, scikit-learn regression, micro:bit gesture models, neural networks and five CV algorithms, generative text, structured output, image generation, VLMs. ‘Look how far you’ve come.’ | 0:00–0:10 | Keep energy high |
| What Will You Build? (10 min) | Options: explore more datasets with pandas/matplotlib; re-train micro:bits for a more complex project; create a new game or app using CV; use a generative model to create text, images, or structured data; combine two or more module types. Create a new notebook and get started. | 0:10–0:20 | Suggest starting from an existing notebook |
| Project Build (80 min) | Students work on their own project. Instructor floats and supports. Encourage copy/paste from earlier notebooks as a starting point. | 0:20–1:40 | No prescribed structure — this is open time |
| Show & Share (20 min) | Optional: groups share their project — what it does, how it works, what surprised them. Celebrate the range of ideas. | 1:40–2:00 | Low-stakes, fun atmosphere |
Resources & Tools
- All notebooks from Days 1–9 as reference
- Jupyter-K12 platform
- OpenRouter API keys