Deep Learning

Winter 2025/26

Course Overview

This course covers advanced topics in deep learning, including neural network architectures, convolutional and recurrent neural networks, autoencoders, transformers, and generative models. Students will gain both theoretical understanding and practical skills in designing and training deep learning models for various applications.

Lectures

📚

Lecture 0: Course Overview

Course content and its evaluation.
List of recommended sources.

This introductory lecture provides an overview of the course structure, content, and evaluation methods. It also includes a list of recommended textbooks and online resources to support student learning throughout the course.

▼

Learning Objectives

  • How to pass the course
  • What is included in this course
  • Recommended literature and online resources
  • Understanding the course structure and expectations
Download Presentation
📚

Lecture 1: Artificial Neural Networks

Fundamentals of neural networks.
Perceptron and multi-layer networks.

This lecture introduces the fundamentals of artificial neural networks, covering the basic building blocks such as neurons, activation functions, and the multi-layer perceptron architecture. The concepts of forward propagation and backpropagation are discussed in detail.

▼

Learning Objectives

  • Understand the basic structure of artificial neurons and activation functions.
  • Learn about multi-layer perceptron architecture.
  • Understand forward propagation and backpropagation algorithms.
  • Explore the foundations for deeper network architectures.
Download Presentation
📚

Lecture 2: Neural Network Architecture

Design of network architectures.
Choosing layers and connections.

This lecture covers the design and selection of neural network architectures, including considerations for layer types, depth, width, and connectivity patterns. Various architectural design principles and their impact on model performance are explored.

▼

Learning Objectives

  • Understand different neural network architecture designs.
  • Learn how to choose appropriate layer types and configurations.
  • Explore the impact of architecture choices on model performance.
  • Understand regularization and optimization techniques for deep networks.
Download Presentation
📚

Lecture 3: Convolutional Neural Networks

Image processing with CNNs.
Convolution and pooling operations.

This lecture introduces convolutional neural networks (CNNs) and their application in image processing tasks. Topics include convolution operations, pooling layers, and well-known CNN architectures used in practice.

▼

Learning Objectives

  • Understand the principles of convolution and pooling operations.
  • Learn about common CNN architectures (LeNet, VGG, ResNet, etc.).
  • Explore applications of CNNs in image classification and recognition.
  • Understand transfer learning and fine-tuning with pre-trained models.
Download Presentation
📚

Lecture 4: Autoencoders

Unsupervised representation learning.
Encoder-decoder architectures.

This lecture covers autoencoders, a class of neural networks used for unsupervised learning of efficient data representations. Topics include the encoder-decoder framework, bottleneck layers, and applications in dimensionality reduction and denoising.

▼

Learning Objectives

  • Understand the encoder-decoder architecture of autoencoders.
  • Learn about different types of autoencoders (sparse, denoising, etc.).
  • Explore applications in dimensionality reduction and feature learning.
  • Understand the role of bottleneck layers in representation learning.
Download Presentation
📚

Lecture 5: Variational Autoencoders

Probabilistic generative models.
Latent space and sampling.

This lecture introduces variational autoencoders (VAEs), combining deep learning with probabilistic inference. Topics include the variational lower bound, reparameterization trick, and the generation of new data samples from learned latent distributions.

▼

Learning Objectives

  • Understand the probabilistic framework behind VAEs.
  • Learn the reparameterization trick for training.
  • Explore the latent space structure and its properties.
  • Understand applications in generative modeling and data synthesis.
Download Presentation
📚

Lecture 6: Gradient Descent

Optimization methods for training.
Variants and convergence.

This lecture provides an in-depth look at gradient descent optimization methods used for training deep neural networks. Topics include batch, mini-batch, and stochastic gradient descent, as well as advanced optimizers like Adam, RMSProp, and learning rate scheduling.

▼

Learning Objectives

  • Understand the fundamentals of gradient descent optimization.
  • Learn about different gradient descent variants and their trade-offs.
  • Explore advanced optimizers (Adam, RMSProp, AdaGrad).
  • Understand learning rate scheduling and convergence properties.
Download Presentation
📚

Lecture 7: Recurrent Neural Networks

Sequential data processing.
LSTM and GRU architectures.

This lecture covers recurrent neural networks (RNNs) designed for sequential data processing. Topics include vanilla RNNs, the vanishing gradient problem, and advanced architectures such as LSTM and GRU that address long-range dependencies.

▼

Learning Objectives

  • Understand the architecture and principles of recurrent neural networks.
  • Learn about the vanishing gradient problem and its solutions.
  • Explore LSTM and GRU architectures for long-range dependencies.
  • Understand applications in sequence modeling and time series analysis.
Download Presentation
📚

Lecture 8: Language Modeling

Statistical and neural language models.
Text generation and prediction.

This lecture focuses on language modeling techniques, from traditional statistical approaches to modern neural language models. Topics include n-gram models, neural language models, and their applications in text generation and natural language understanding.

▼

Learning Objectives

  • Understand the fundamentals of language modeling.
  • Learn about statistical and neural approaches to language modeling.
  • Explore perplexity and other evaluation metrics.
  • Understand applications in text generation and NLP tasks.
Download Presentation
📚

Lecture 9: Representation of the Meaning of Words

Word embeddings and vector spaces.
Semantic representations.

This lecture covers methods for representing word meaning in vector spaces, including Word2Vec, GloVe, and contextual embeddings. The relationships between words in embedding spaces and their applications in NLP are explored.

▼

Learning Objectives

  • Understand distributional semantics and word embeddings.
  • Learn about Word2Vec, GloVe, and FastText models.
  • Explore properties of word vector spaces and analogies.
  • Understand contextual embeddings and their advantages.
Download Presentation
📚

Lecture 10: Transformer Network Type

Attention mechanisms.
Self-attention and transformer architecture.

This lecture introduces the transformer architecture, which has revolutionized deep learning. Topics include the self-attention mechanism, multi-head attention, positional encoding, and applications in both NLP and computer vision.

▼

Learning Objectives

  • Understand the self-attention mechanism and its variants.
  • Learn about the transformer encoder-decoder architecture.
  • Explore positional encoding and multi-head attention.
  • Understand applications of transformers (BERT, GPT, Vision Transformers).
Download Presentation
📚

Lecture 11: Object Detection

Detecting objects in images.
Region-based and single-shot methods.

This lecture focuses on object detection techniques in deep learning, covering both region-based methods (R-CNN family) and single-shot detectors (YOLO, SSD). Practical applications and evaluation metrics for object detection are discussed.

▼

Learning Objectives

  • Understand region-based object detection methods (R-CNN, Fast R-CNN, Faster R-CNN).
  • Learn about single-shot detection methods (YOLO, SSD).
  • Explore evaluation metrics for object detection (IoU, mAP).
  • Understand real-world applications of object detection.
Download Presentation Example Video
📚

Lecture 12: Generative Models

Generating new data with deep learning.
GANs and diffusion models.

This lecture covers generative models in deep learning, including Generative Adversarial Networks (GANs), diffusion models, and their variants. Applications in image synthesis, style transfer, and data augmentation are explored.

▼

Learning Objectives

  • Understand the principles of generative adversarial networks.
  • Learn about different GAN variants and training techniques.
  • Explore diffusion models and their generation process.
  • Understand applications in image synthesis and data augmentation.
Download Presentation

Exercises

💻

Exercise 1: Basic Neural Network

MNIST digit classification.
TensorFlow 2 and Keras basics.

Building and training a basic neural network for digit classification using the MNIST dataset. Introduction to TensorFlow 2 and Keras concepts.

▼

Exercise Objectives

  • Set up TensorFlow 2 and Keras environment
  • Build a basic neural network architecture
  • Train and evaluate the model on MNIST
  • Understand fundamental deep learning concepts
Jupyter Colab
💻

Exercise 2: Regression with Deep Learning

Auto MPG dataset.
Predicting fuel consumption.

Solving regression problems using deep learning on the Auto MPG dataset to predict fuel consumption based on vehicle characteristics.

▼

Exercise Objectives

  • Understand regression with neural networks
  • Preprocess data for deep learning models
  • Train and evaluate regression models
  • Analyze model performance metrics
Jupyter Colab
💻

Exercise 3: Convolutional Neural Networks

CIFAR-10 image classification.
CNN architecture basics.

Introduction to Convolutional Neural Networks for image classification using the CIFAR-10 dataset. Building and training CNN architectures.

▼

Exercise Objectives

  • Understand CNN architecture components
  • Implement convolution and pooling layers
  • Train CNNs for image classification
  • Evaluate and visualize CNN performance
Jupyter Colab
💻

Exercise 4: Transfer Learning

Image and time series classification.
1D convolutions with FordA dataset.

Transfer learning techniques for images and time series classification. Using 1D convolutions with the FordA dataset for sequence classification.

▼

Exercise Objectives

  • Understand transfer learning principles
  • Apply pre-trained models to new tasks
  • Implement 1D convolutions for time series
  • Fine-tune models for specific datasets
Jupyter Colab
💻

Exercise 5: Autoencoders and VAEs

Image reconstruction and generation.
MNIST dataset experiments.

Implementing Autoencoders and Variational Autoencoders for image reconstruction and generation using the MNIST dataset.

▼

Exercise Objectives

  • Build autoencoder architectures
  • Understand latent space representations
  • Implement Variational Autoencoders
  • Generate new images from latent space
Jupyter Colab
💻

Exercise 6: Recurrent Neural Networks

Sentiment analysis on Twitter data.
GloVe embeddings integration.

Using Recurrent Neural Networks for sentiment analysis on Twitter data with pre-trained GloVe word embeddings.

▼

Exercise Objectives

  • Understand RNN architecture for sequences
  • Use pre-trained word embeddings (GloVe)
  • Build sentiment classification models
  • Evaluate text classification performance
Jupyter Colab
💻

Exercise 7: Word Embeddings and Text Generation

Word2Vec Skip-Gram method.
Character-based RNN text generation.

Implementing Word2Vec Skip-Gram method for word embeddings and character-based RNNs for text generation using the Harry Potter corpus.

▼

Exercise Objectives

  • Implement Word2Vec Skip-Gram model
  • Train custom word embeddings
  • Build character-level language models
  • Generate text using trained RNNs
Jupyter Colab
💻

Exercise 8: Attention Mechanisms

Self-attention implementation.
Dot-product attention for NLP.

Implementing attention mechanisms including self-attention and dot-product attention for natural language processing tasks.

▼

Exercise Objectives

  • Understand attention mechanism principles
  • Implement self-attention layers
  • Apply dot-product attention
  • Integrate attention into NLP models
Jupyter Colab
💻

Exercise 9: Transformer Models

HuggingFace library integration.
TensorFlow 2 for NLP tasks.

Using Transformer models with the HuggingFace library integrated with TensorFlow 2 for various NLP tasks.

▼

Exercise Objectives

  • Use HuggingFace Transformers library
  • Load and fine-tune pre-trained models
  • Apply transformers to NLP tasks
  • Integrate with TensorFlow 2 workflows
Jupyter Colab
💻

Exercise 10: Object Detection

Object localization with CNNs.
YOLOv8 implementation.

Object localization with CNNs and YOLOv8 for detecting and locating objects in images. Practical implementation of state-of-the-art detection methods.

▼

Exercise Objectives

  • Understand object detection principles
  • Implement object localization with CNNs
  • Use YOLOv8 for real-time detection
  • Evaluate detection performance metrics
Jupyter Colab
💻

Exercise 11: Time Series Forecasting

Natural gas consumption prediction.
Deep learning for forecasting.

Time series forecasting for natural gas consumption prediction using deep learning techniques and sequence models.

▼

Exercise Objectives

  • Preprocess time series data for DL
  • Build forecasting models with neural networks
  • Evaluate prediction accuracy
  • Apply models to real-world forecasting
Jupyter Colab

CNN Project - Image Classification

Project Overview

Complete a deep learning project focused on convolutional neural networks for image classification. You will build both a custom CNN architecture and implement transfer learning with pre-trained models, comparing their performance on your chosen dataset.

10-20 points

Project Deadline

April 19, 2026

Dataset Documentation (Mandatory)

  • Provide number of images, number of classes, and class balance information
  • Visual inspection of sample images before model development
  • Brief written description of the dataset characteristics

Performance Metrics

  • Select and justify evaluation metrics (accuracy, precision, recall, F1-score, etc.)
  • Consider class balance and task specifics when choosing metrics
  • State which metric is most important and explain why

Model Development (Minimum 2 Models Required)

Model 1 - Custom Architecture

  • Build CNN from scratch with original design
  • Document all experiments and hyperparameter tuning
  • Include brief comments on experimental effects (BatchNormalization, layer sizes, optimizer choices)

Model 2 - Transfer Learning

  • Implement pre-trained models (ResNet50, Inception, MobileNet, etc.)
  • Fine-tune for the specific dataset
  • Compare performance against custom model

Project Deliverables

  • Jupyter Notebook with integrated descriptions, OR PDF report + source code files
  • Mandatory: Summary highlighting key insights at the end
  • Estimated time: 5-10 hours

Available Datasets

LEGO Brick Images

Dataset of LEGO brick images for classification. Two versions available on Kaggle.

View Dataset on Kaggle

Chest X-Ray Images (Pneumonia)

Medical imaging dataset for pneumonia detection from chest X-rays.

View Dataset on Kaggle

GTSRB - German Traffic Sign Recognition

Traffic sign recognition benchmark dataset with multiple classes.

View Dataset on Kaggle

LEGO Minifigures Classification

Dataset for classifying different LEGO minifigure characters.

View Dataset on Kaggle

Custom Dataset

You may use a custom dataset with instructor approval. Contact via email to discuss your choice.

RNN Project - Text Classification

Project Overview

Implement recurrent neural network models for text classification tasks. You will build custom RNN architectures and utilize pre-trained embeddings or transformer models, comparing their effectiveness on your chosen text dataset.

10-20 points

Project Deadline

May 16, 2026

Dataset Documentation (Mandatory)

  • Provide brief description including instance count, class quantity, and class distribution
  • Include sample text examples from the dataset
  • Document any preprocessing steps applied to the text data

Performance Metrics

  • Select appropriate evaluation measures (accuracy, precision, recall, F1-score, etc.)
  • Document which score is most important with justification
  • Consider class balance and task specifics in your metric selection

Model Development (Minimum 2 Models Required)

Model 1 - Custom Architecture

  • Build RNN architecture from scratch (LSTM, GRU, or vanilla RNN)
  • Include experimentation documentation with brief comments
  • Explore hyperparameter variations and their effects on performance

Model 2 - Transfer Learning

  • Employ pre-trained embeddings (GloVe, Word2Vec, FastText) or transformer models
  • Fine-tune for the specific dataset where applicable
  • Compare results against custom models

Project Deliverables

  • Jupyter Notebook with integrated descriptions, OR PDF report + source code files
  • Mandatory: Summary at the end highlighting the most interesting insights
  • Estimated time: 5-10 hours

Recommended Datasets

Sentiment140 - Twitter Sentiment Dataset

1.6 million tweets for sentiment analysis. Subsetting recommended due to size.

View Dataset on Kaggle

News Category Dataset

News articles categorized into different topics for text classification.

View Dataset on Kaggle

Coronavirus Tweets NLP - Text Classification

COVID-19 related tweets for NLP text classification tasks.

View Dataset on Kaggle

Trip Advisor Hotel Reviews

Hotel reviews for sentiment analysis and rating prediction.

View Dataset on Kaggle

Custom Dataset

You may use a dataset of your own selection from Kaggle with instructor approval via email. RNN implementation in non-classification contexts is also acceptable for semestral projects with prior approval.

Final Project - Deep Learning Analysis

Project Overview

Create a comprehensive analysis of a self-selected dataset from image, text, or time series domains. Implement multiple deep learning models with emphasis on creativity, thorough experimentation, and systematic documentation. This project requires deployment pipeline implementation.

20-40 points

Project Deadline

June 7, 2026

Dataset Selection

  • Choose from Kaggle or similar sources (instructor approval required)
  • Document instance count and class distribution
  • Include data examples and characteristics
  • Specify domain classification (image/text/time series)

Model Development

Custom Models

  • Build baseline architectures from scratch
  • Document hyperparameter tuning (batch sizes, optimizers)
  • Use optimization frameworks like Optuna

Transfer Learning

  • Images: Pre-trained models (ResNet, EfficientNet, YOLO)
  • Text: HuggingFace Transformers, word embeddings (GloVe, FastText, Word2Vec)
  • Include data preprocessing, resampling, and augmentation techniques

Evaluation Metrics

  • Select appropriate metrics (Accuracy, Precision, Recall, F1-score)
  • Justify which metric is most important given task characteristics
  • Include performance comparison tables and visualizations

Experiment Tracking

Implement systematic documentation using one of the following tools:

Deployment Pipeline

  • Export selected model (ONNX format recommended)
  • Create inference class with preprocessing and prediction methods
  • Include usage documentation with examples

Project Deliverables

  • Jupyter Notebook with descriptions, OR PDF report + source code
  • Mandatory: Summary of the most interesting insights obtained
  • Experiment documentation with results tables and plots
  • Model comparison analysis
  • Estimated time: 10-15 hours (varies by skill level)

Special Project - Rankacy × VSB Cooperation

Project Overview

Rankacy is a CS2 (Counter-Strike 2) analytics platform offering rich gameplay data for machine learning research. This cooperation provides access to large-scale real-world datasets and a range of project topics — from semester exercises to full thesis work — covering predictive modelling, computer vision, reinforcement learning, and more.

Available Datasets

  • ~300 GB of raw .dem demo files from CS2 matches
  • Pre-extracted time series for every demo — ready for ML pipelines
  • Additional data available on request — no hard cap on scale
  • Video data: students can render their own footage from the provided .dem files using the CS2 client (Windows + installed game required)

Small Projects — Semester Exercises

1. Prediction from Aggregated Data

  • Predict the winning team of the current round or the full match
  • Predict the winning team for the next N rounds
  • Estimate the score margin (e.g. CT side wins by 2 rounds)
  • Use classical ML or lightweight deep learning models on the extracted time series

2. Clustering, Data Analysis & Anomaly Detection

  • Detect lurking behaviour — players frequently moving alone — and analyse whether it is actually harmful
  • Identify abnormal cursor / aiming patterns: unusually fast head-snap, repetitive bot-like movement traces
  • Extract team tactics for specific scenarios (retakes, early-game rotations)
  • Build a simple vector embedding for similarity search across game situations

3. Simple Computer Vision Applications

  • Enemy object detection in rendered video — compare accuracy and latency across model sizes and resolutions
  • OCR-based HUD reconstruction: read timer, HP, weapon, ammo from the screen and reconstruct game state

Possible Large Projects — Thesis Topics

1. Large Language Models

  • AI Match Commentator — integrate an LLM to generate live commentary from game events
  • Semantic Situational Search — vector embeddings for game moments; natural-language queries such as "three players rushing site A with grenades"

2. Reinforcement Learning

  • Train bots from scratch without relying on human-play data
  • Combine RL with imitation learning: pre-train on human demos, then fine-tune selected policies via RL

3. Computer Vision

  • 3D Navigation from Visual Input — agents that navigate the CS2 environment using only raw pixels (also applicable in NVIDIA Isaac or similar simulators)
  • Game-State Reconstruction from Video — CV models that recover structured data typically extracted from .dem files, potentially combined with simple predictive models

4. Predictive Models

  • Player Skill Estimation — predict Premier / Competitive rank; validate against ground-truth rank labels
  • Duel Outcome Prediction — model the survival probability in isolated 1v1 fights or short combat segments; usable as an expected-kill metric