DL 201 · HIT · Foundation Course · 13 Weeks

Introduction to Deep Learning

Foundations of Neural Networks with PyTorch

Prerequisite: Introduction to Machine LearningRequired for: all CS specializations (mandatory)Feeds into: Advanced LLMs and Computer VisionFormat: 3 h lecture + 2 h practice + a homework labAssessment: labs and projects, no written exams

HIT course catalogue package

Department submission documents in the HIT form, on the official letterhead (Word, downloadable):

Syllabus (English)Syllabus (Hebrew)Rationale Catalogue summary

About this course

This is the foundational deep-learning course, required of every computer-science student and taught across all specializations. It turns an introductory machine-learning background into working neural-network skill in PyTorch: framing a task in tensor terms, then building, training, and debugging networks. The emphasis is on building and experimentation, not on watching. Each week has a 3-hour lecture (theory), a 2-hour instructor-led practice lesson (live implementation and worked examples), and a hands-on lab set as homework.

Rationale. Modern AI rests on a shared deep-learning foundation. This course provides that common base for continued specialization in artificial intelligence, including computer vision, large language models, and others. It is valuable in its own right, not only as a step toward later courses. It is project- and lab-based and designed for the way students will actually work, with an AI coding assistant at hand, while keeping the learning genuine through a Build, Predict, and Explain model.

Course format

Each week has three parts: a 3-hour lecture (theory), a 2-hour practice lesson in which the instructor demonstrates implementations and works through examples, and a weekly lab set as homework. The thirteen weeks form four parts: Foundations (weeks 1 to 3), Training Infrastructure (4 to 7), Architectures and Representation Learning (8 to 12), and Integration (13). A mid-term mini-project consolidates Parts I and II; a final project consolidates the whole course.

Expected outcomes

By the end of the course, students will be able to:

1🎯Frame ML tasks as networks (tensors in, a loss out).

2🧮Represent data as tensors and use them fluently.

3🔀Build data pipelines with Dataset and DataLoader.

4📉Use automatic differentiation to compute gradients.

5🧠Implement neural networks in PyTorch.

6⚙️Reason about optimization (SGD, Adam, learning rates).

7🩺Diagnose training issues (overfitting, instability).

8🏗️Build MLPs, CNNs, RNNs, LSTMs/GRUs, and autoencoders.

9🧬Apply representation learning and transfer learning.

10🔗Carry a transferable base into advanced LLM and vision courses.

Prerequisites: review and self-check

The course assumes a prior machine-learning course and the background below. Each row links a short refresher and a set of self-check questions, so readiness can be confirmed before Week 1.

Subject	Background topics	Material
∑Mathematics	Linear algebra, probability, multivariable calculus, gradients, optimization	Review Self-check
🐍Python	Comprehensions, generators, dunder methods, NumPy versus lists, PyTorch idioms	Review Self-check
🧮Machine learning	Regression, classification, loss versus metric, overfitting, regularization, bias-variance	Review Self-check

Weekly materials

Wk	Topic	Materials
Part I · Foundations
1	Deep Learning Overview & ML-to-Network FramingWhat deep learning is; framing a task as tensor inputs, model outputs, and a loss function.	Lesson plan Practice notebook Self-check Homework lab
2	Tensors & Data RepresentationTensor operations, shapes, broadcasting, devices; representing images, text, and tabular data as tensors.	Lesson plan Practice notebook Self-check Homework lab
3	MLPs & BackpropagationMultilayer perceptrons; the forward pass; backpropagation mechanics via PyTorch autograd.	Lesson plan Practice notebook Self-check Homework lab
Part II · Training Infrastructure
4	Data PipelinesThe Dataset and DataLoader abstractions; batching, shuffling, transforms, and splits.	Lesson plan Practice notebook Self-check Homework lab
5	Loss Functions & MetricsTask-appropriate losses (cross-entropy, MSE, BCE); metrics; the train and eval loop.	Lesson plan Practice notebook Self-check Homework lab
6	OptimizationGradient descent; SGD, momentum, and Adam; learning rates and optimization dynamics.	Lesson plan Practice notebook Self-check Homework lab
7	Regularization & GeneralizationOverfitting; dropout, weight decay, early stopping; basic data augmentation.	Lesson plan Practice notebook Self-check Homework lab
Part III · Architectures & Representation Learning
8	Convolutional Networks IConvolution, pooling, and feature maps; building a CNN image classifier.	Lesson plan Practice notebook Self-check Homework lab
9	Convolutional Networks IIBatch and layer normalization; residual connections; modern CNN design.	Lesson plan Practice notebook Self-check Homework lab
10	Recurrent Networks (RNNs)Sequence data and recurrence; the RNN cell; backpropagation through time; vanishing and exploding gradients.	Lesson plan Practice notebook Self-check Homework lab
11	LSTMs, GRUs & Sequence TasksGated recurrent units; how gates restore gradient flow; LSTM versus GRU; sequence classification and sequence-to-sequence tasks.	Lesson plan Practice notebook Self-check Homework lab
12	Representation LearningAutoencoders and latent representations; contrastive and self-supervised methods.	Lesson plan Practice notebook Self-check Homework lab
Part IV · Integration
13	Integration & Transfer LearningTransfer learning and fine-tuning; model inference; the end-to-end workflow into the advanced courses.	Lesson plan Practice notebook Self-check Homework lab

AI usage

Using an AI assistant is highly encouraged in this course; it reflects how the work is really done. Two conditions keep the learning genuine: students keep full ownership of, and responsibility for, everything they submit, and must be able to explain and defend any part of it. The Predict, Explain, and short oral-defense steps verify understanding rather than authorship; where an assistant was used, it should be disclosed.

For what a strong submission looks like in practice, see a fully worked sample submission that follows this model end to end.

Every weekly lab follows a three-part model:

Part A · AI assistant welcomeBuild

Produce working code that meets a specification or reaches a target metric; an AI assistant may be used freely.

Part B · reasoningPredict & probe

Before running anything, write down the expected outcome, then run controlled experiments and compare.

Part C · in plain languageExplain & defend

Explain why the solution works, where it would break, and what changed; be ready to defend any line.

Assessment and grading

Grading is project- and lab-based, with weight on the parts an AI assistant cannot do for the student: reasoning, interpretation, and defense. There are no written exams.

Component	What it covers	Weight
Weekly labs	Eleven labs (best 10 count), graded mostly on the Predict and Explain parts.	40%
Mid-term mini-project	A CNN-based project (around weeks 9 to 10): build, train, ablate, and report.	20%
Final project	Implementation, a written report, an AI-use reflection, and a short oral defense.	35%
Participation	In-class exercises and lab engagement.	5%

Mid-term mini-project

20% of the grade · around weeks 9 to 10 · CNN-based

The mid-term is a convolutional-network project on an image task: build it, train it, run a controlled ablation, and report the findings. Pick one of the examples below or propose another in the same spirit. Datasets are suggestions; any comparable small image dataset works.

Mid-term project examples →

Final project

35% of the grade with a short oral defense · proposal around week 8 · due week 13

The final project takes a task end to end with any architecture family from the course. Work solo or in a pair: frame the task, build a suitable network, train and tune it, diagnose failures, and report results. The examples below span vision, sequences, and representation learning; or propose a variant instead.

Deliverables are a one-page proposal (around week 8), a code submission, a short report, a half-page AI-use reflection, and a short oral defense where understanding, rather than authorship, is confirmed.

Final project examples →

Tools and resources

Core stack: Python 3.11+, PyTorch, NumPy, and Matplotlib; Jupyter notebooks or Google Colab.
AI assistant: part of the toolkit, expected for the Build portion of the labs.
Compute: a GPU helps but is not required; Colab provides free GPU access.
Reference reading: Dive into Deep Learning (d2l.ai) and the official PyTorch tutorials.
Course materials: lecture slides, exercise notebooks, and starter code are posted weekly.