Syllabus
Deep Learning — CS 4715/5715
University of Idaho · Fall 2026 · Mon/Wed 6:00–7:15 PM Pacific · Engineering Physics (EP) 204
- Instructor: Boyu Zhang · boyuz@uidaho.edu
- Office hours: posted on Canvas (in person + Zoom)
- Sections: on-campus (Moscow), Virtual Meeting (synchronous, over Zoom), videoconferencing from CdA (synchronous), and Online (Web) asynchronous (CS 5715 only)
- Course site: this website · Submissions & grades: Canvas
Course description
Deep learning is the engine behind modern AI: image recognition, machine translation, code assistants, and chatbots all run on neural networks trained by gradient descent. This course takes you from the mechanics of backpropagation — which you will implement yourself — through convolutional networks, Transformers, and large language models, to diffusion models and the practical questions of efficiency, evaluation, and safety that dominate the field today.
The course is implementation-first: every major idea is something you build and run. You will write an automatic differentiation engine from scratch, train networks in PyTorch, implement a Transformer, fine-tune a pretrained model with LoRA, and finish with a semester project: a report, a recorded presentation, and code you must be able to explain line by line.
Prerequisites: comfortable Python and NumPy programming, plus an introductory machine learning course (or instructor permission). We assume you know what a train/test split, a loss function, and gradient descent are; we start at neural networks.
Framework: PyTorch throughout. A laptop is enough for the day-to-day work; a free Google Colab account covers the parts that need a GPU (see Compute requirements).
Textbooks (all free online)
- Dive into Deep Learning (Zhang, Lipton, Li, Smola) — primary reference for Modules 1–3; runnable PyTorch notebooks.
- Understanding Deep Learning (Simon J.D. Prince, MIT Press) — secondary reference, especially for Transformers and diffusion.
- Course reading chapters written for this class cover topics newer than both books (LoRA/PEFT, alignment, LLM evaluation, efficiency).
- Optional theory reference: Deep Learning (Goodfellow, Bengio, Courville).
Grading
There is no midterm exam and no final exam. Continuous assessment — the four module quizzes — replaces them.
| Component | CS 4715 | CS 5715 | What it is |
|---|---|---|---|
| Homework HW1–HW4 | 40% | 40% | Four equally weighted assignments: micro-autograd, CNNs & transfer learning, a Transformer from scratch, evaluation & efficiency. Graded mostly by passing tests, plus a short write-up. |
| Module quizzes (4) | 15% | 15% | Closed-book, ~10 questions, at the end of S09, S13, S23, and S27. Equally weighted; none dropped. |
| Semester project | 35% | 35% | Pre-proposal, proposal, final report, and a recorded presentation; students the instructor calls also do a code defense. |
| Paper reading responses | — | 10% | CS 5715 only: four one-page structured responses, one paper per module. None dropped. |
| Participation | 10% | 10% | Attendance, answering questions in class, and similar contributions. |
| Bonus | up to +10% | up to +10% | Other kinds of contribution: finding bugs in the course code, catching issues in the materials, and the like. |
CS 4715 components sum to 100%. CS 5715 components sum to 110% — the paper reading responses raise the graduate ceiling rather than rescaling the other components — so a CS 5715 total can reach 110% before bonus. Bonus can lift either section up to 10 points further. Both sections share one Canvas course; assignment-group weights are configured so that each section’s Canvas running total matches its column above exactly.
Letter grades: A ≥ 90, B ≥ 80, C ≥ 70, D ≥ 60, F below 60. Cutoffs may be lowered (never raised) at the instructor’s discretion.
Late policy
Every dated submission (homework, project pre-proposal/proposal/report) has:
- a 12-hour grace period after the deadline — no penalty, no questions asked;
- after the grace period, −10% of the assignment’s maximum score per 24 hours (or fraction thereof), measured from the original deadline;
- penalties stop at 60% credit: work submitted any time before the last day of classes earns at least 60% of the points it would have received on time.
Quizzes cannot be submitted late. A make-up (or early sitting) is arranged in exactly three cases: a planned absence (travel, a conference, any foreseeable conflict) requested at least one week before quiz day; a foreseeable illness or medical treatment reported at least three days before quiz day; or a sudden illness or emergency — contact the instructor within 48 hours afterward, with documentation. Otherwise there are no make-up quizzes, and all four quizzes count. Regrade requests for any assessment must be submitted in writing within 7 days of the grade being posted.
Quizzes by modality
| Module quizzes (4) | |
|---|---|
| On-campus | Canvas quiz, last 30 minutes of a Wednesday class (6:45–7:15 PM Pacific) |
| Virtual Meeting (synchronous) | Canvas quiz, taken during the same class-time window |
| Videoconferencing from CdA (synchronous) | Canvas quiz, taken during the same class-time window |
| Online (Web) asynchronous | Canvas quiz, opens with the class at 6:45 PM Wednesday and closes Thursday 11:59 PM (Pacific); take it any time in that window |
Students with CDAR quiz accommodations use the Online (Web) window. There is no access code. Every section uses the same question bank. The synchronous sections take the quiz in the 30-minute class window; in the Online (Web) window there is no time limit once the quiz is open. Each module quiz has ~10 questions (multiple choice, multiple select, and code reading) covering that module’s sessions, all of them already taught.
Midterm grade reporting & withdrawal deadline
The university requires midterm grades in Midterm Exam Week. Your reported midterm grade is your cumulative course grade at that point — HW1 and Quizzes 1–2. It will be visible to you on Canvas the same week — before the university’s deadline to withdraw or change to audit (the date is on the Canvas calendar), so you can make an informed decision.
AI use policy (three tiers)
| Tier | Applies to | Rules |
|---|---|---|
| Tier 0 — Closed | All quizzes | No AI tools, no internet resources, no collaboration. Violations are academic dishonesty. |
| Tier 1 — Restricted | Homework HW1–HW4 | You may ask AI tools conceptual questions (“what does a stride do?”), syntax questions, and for help interpreting error messages. You may not ask an AI to write or complete your solution code, and you may not paste assignment problems into an AI tool. We recommend disabling AI autocomplete in your editor for homework. Each submission includes a brief statement of how you used AI. |
| Tier 2 — Open with disclosure | Semester project | AI tools may be used as collaborators — brainstorming, coding, editing. Your report must include an AI Usage section describing what tools you used, for what, and which contributions are your own. A code defense, for any student the instructor calls, verifies personal understanding. |
Why the difference? Homework is where you build skills — outsourcing it defeats its purpose and will show on quizzes and in a code defense. The project is where you do research — there, modern tools are part of the craft, used transparently.
Academic integrity follows the University of Idaho Student Code of Conduct. Work you submit must reflect your own understanding; you must be able to explain any line of code you turn in.
Course materials and AI disclosure
I ask you to be transparent about how you use AI, so here is my side of that bargain.
The materials on this site — the reading chapters, slide decks, homework assignments and their test suites, quiz items, and this syllabus — were drafted with substantial help from generative AI assistants (primarily Anthropic’s Claude, with a second model used for review), working from my specifications and under my direction. I reviewed the result and I am responsible for what it says. Teaching, grading, feedback on your work, and every decision about your grade are mine.
What this means in practice:
- The code is real. Every code example in the readings was actually executed, and the outputs printed beneath it are the outputs of that run — not plausible-looking text about what the code would do. The homework test suites are run automatically before release against both an untouched starter (everything must fail) and a reference solution (everything must pass).
- Errors are still possible. Machine-drafted prose can be confidently wrong, most often about history, attribution, and numbers. If something looks wrong, say so — in class, in office hours, or by email. Corrections are made to the site during the semester, and I would much rather fix an error than have you memorize it.
- For research claims, go to the source. Where a reading cites a paper, the paper is the authority; treat the reading as an explanation of it, not a replacement for it.
- This does not change your rules. The three tiers above still govern your work: no AI on quizzes, restricted use on homework, open use with disclosure on the project. The difference is not hypocrisy — it is the difference between building a skill and producing a deliverable once you have it.
Consider this section a worked example of the Tier 2 disclosure the project asks of you: which tools, used for what, and who is accountable for the result.
Schedule — 26 teaching sessions in 25 classes + 2 code-defense days (S15 is not held this term; S20 and S21 share one class)
Dates live in Canvas. This schedule is ordered by session so that it stays correct when the calendar shifts; every due date, quiz window, and exam time is on the Canvas calendar, which is the authoritative one. There is no class on Labor Day or during Fall Recess, and No-Exam Week (the last week of instruction) contains no quizzes or exams — only code defenses for the students the instructor calls. Quizzes take the last 30 minutes of a Wednesday session.
Module 1 — Foundations (S01–S08)
| # | Topic | Assessment events | Prep |
|---|---|---|---|
| S01 | Course introduction: why deep learning works now; how this course runs | — | reading |
| S02 | From linear models to multilayer perceptrons; activations, expressivity | — | reading |
| S03 | Loss functions and gradient descent; cross-entropy; numerical stability | — | reading |
| S04 | Backpropagation I: computation graphs and the chain rule | HW1 out (micro-autograd) | reading |
| S05 | Backpropagation II: vectorized backprop; how autograd engines work | — | reading |
| S06 | Optimizers: SGD, momentum, Adam/AdamW; learning-rate schedules | — | reading |
| S07 | Regularization and initialization; BatchNorm and LayerNorm | — | reading |
| S08 | PyTorch in practice: nn.Module, optim, DataLoader, the training loop |
HW1 due | reading |
Module 2 — Convolutional networks & training practice (S09–S12)
| # | Topic | Assessment events | Prep |
|---|---|---|---|
| S09 | CNNs I: convolution, pooling, receptive fields | Quiz 1 (Module 1) | reading |
| S10 | CNNs II: ResNet and modern architecture design | — | reading |
| S11 | Transfer learning and data augmentation | Project guide out | reading |
| S12 | Training in practice: debugging, overfitting diagnosis, experiment tracking | HW2 out (CNN + transfer) · Midterm Exam Week | reading |
Module 3 — Sequences, Transformers & LLMs (S13–S22)
| # | Topic | Assessment events | Prep |
|---|---|---|---|
| S13 | Sequence modeling: RNNs and LSTMs; why they were replaced | Quiz 2 (Module 2) · Midterm Exam Week · Project pre-proposal due end of this week | reading |
| S14 | Attention: from seq2seq bottlenecks to queries, keys, and values | Midterm grades reported | reading |
| S15 | Guided review of S01–S13: not held this term; the review guide and the review deck are for self-study | — | reading |
| S16 | Transformer I: self-attention, multi-head attention, positional encoding | — | reading |
| S17 | Transformer II: the full block; BERT vs. GPT; tokenization | — | reading |
| S18 | LLM pretraining: data, scaling laws, capabilities and limits | HW2 due · HW3 out (Transformer from scratch) | reading |
| S19 | Fine-tuning and parameter-efficient adaptation: LoRA and friends | — | reading |
| S20 | Decoding and inference: sampling strategies, prompting, in-context learning | Taught together with S21 in one class this term | reading |
| S21 | Alignment overview: SFT → RLHF → DPO, and what they cost | Taught together with S20 in one class this term | reading |
| S22 | Vision Transformers and multimodal models: ViT, CLIP | HW3 due | reading |
Module 4 — Generative models, efficiency & evaluation (S23–S27)
| # | Topic | Assessment events | Prep |
|---|---|---|---|
| S23 | Autoencoders and VAEs: latent variables, the reparameterization trick | Quiz 3 (Module 3) · Project proposal due end of this week | reading |
| S24 | Generative models I: GANs — the idea and its failure modes | — | reading |
| S25 | Generative models II: diffusion models — noising, denoising, sampling | — | reading |
| S26 | Efficiency and scale: mixed precision, distributed training ideas, quantization, distillation | HW4 out (evaluation + efficiency) | reading |
| S27 | Evaluation and safety: benchmarks done right, error bars, bias, model cards | Quiz 4 (Module 4) · Project report due end of this week | reading |
| — | Fall Recess — no class | — | — |
(Fall Recess falls between S25 and S26.)
Finale (S28–S29)
| # | Topic | Assessment events | Prep |
|---|---|---|---|
| S28 | Code defenses I (No-Exam Week: no quizzes/exams); only students called attend | Recorded presentation due the night before | — |
| S29 | Code defenses II; course wrap-up and what’s next, posted on the course site | HW4 due | — |
There is no final exam; the course ends with the project report, the recorded presentations, and the code defenses.
Homework (four assignments)
Each assignment is a small, tested Python project: you receive a starter package with documented stubs and a pytest suite; your grade is primarily determined by passing tests, plus a short write-up. Four assignments carry equal weight, so each is worth 10% of the course grade — treat them accordingly. The test suites run on CPU in seconds. Assignments needing real training provide a free-tier Google Colab path.
| HW | Topic | Out → Due |
|---|---|---|
| HW1 | Micro-autograd: a scalar automatic-differentiation engine | S04 → S08 |
| HW2 | CNNs & transfer learning: convolution and pooling by hand; a frozen-trunk transfer experiment | S12 → S18 |
| HW3 | Transformer from scratch: attention, multi-head, blocks; train a tiny language model | S18 → S22 |
| HW4 | Evaluation & efficiency (NumPy only): bootstrap CIs, a paired model comparison, stable perplexity, int8 quantization with a before/after error | S26 → S29 |
Submission: each homework is a zip attached to its Canvas assignment. Unzip it, work in the one starter module, and run the included tests locally. Each homework has two Canvas assignments: upload that one file to HWn Code and paste your WRITEUP.md into HWn Write-up; resubmit as often as you like before the deadline (the last submission counts). We grade by running the official tests against your file, so your local test result is a preview of your grade. Step-by-step instructions are in every homework README.
Semester project
Teams of 1–3 (CS 5715: max 2); every member submits every deliverable, and grades are per student. Pick any deep learning problem; the Google Colab free tier is enough for a well-scoped project. Full details, rubric, and the model card template are in the project guide (released at S11).
- Pre-proposal due the week of S13 · Proposal due the week of S23 · Final report due the week of S27 · Recorded presentation (video) due the Sunday before S28 · Code defense at S28 or S29, for students the instructor calls. Exact dates are on the Canvas calendar.
- Fair comparison policy: no model family is required or favored. A carefully designed experiment where the simple baseline wins is a successful project. You are graded on experimental design and analysis, not leaderboard position.
- Code defense: after reading the reports and watching the videos, the instructor calls some students individually to answer questions about code they wrote; everyone else has no class meeting in S28 or S29.
CS 5715 paper readings
Graduate students read one paper per module (four total) and submit a one-page structured response; all four are due by Friday, December 4, the last day before No-Exam Week, with each module’s week as the recommended time. Papers, guiding questions, and dates are on the graduate reading list.
Compute requirements
You will need a computer that runs Python 3.12+, and a free Google Colab account for the GPU-dependent parts of the course. No paid compute and no personal GPU are required:
- The homework test suites are designed to run on CPU in seconds, so day-to-day red/green feedback needs nothing beyond your laptop. The training-oriented parts of the homework (the transfer experiment in HW2, the small language model in HW3) also run on CPU in seconds. Most semester projects do need a GPU; the free Colab tier is sufficient and is the expected way to run them.
- Keep runs small by design — a course theme is getting signal from small, well-designed experiments.
Accessibility & university policies
If you need accommodations, contact the U of I Center for Disability Access and Resources (CDAR) and share your accommodation letter early so we can arrange quiz and exam logistics (every modality can be accommodated). University policies on academic integrity, civil rights, and safety apply as stated in the current U of I catalog and Student Code of Conduct.