February 2026 material

.gitignore

@@ -1,8 +1,10 @@
-data/
+.venv
+.ipynb_checkpoints
 *.org
 *.db
-src/*/*.md
-.idea/
-.ipynb_checkpoints/
-__pycache__/
-*.pyc
+src/S*/*.md
+uv.lock
+.python-version
+pyproject.toml
+jupytext.toml
+data/*.csv

README.md

@@ -0,0 +1,45 @@
+# Machine Learning in Python
+
+This repository is associated with the "Machine Learning in Python" training. The lastest iteration of this training is February 2026, and the material for this iteration can be found in the `feb2026` branch of the repository.
+
+
+## Introduction
+
+The training is structured in six sessions spread over three weeks, with two sessions per week.
+
+Each session is four hours long, with a total in-class time for the entire training of 24 hours. To get the most benefit from the training, we recommend that you spend as much time outside of the class working on your own, with your own datasets.
+
+Each session is made up of several concepts, and each concept is structured as follows:
+
+-   A concept is introduced via slides and in a Jupyter notebook
+-   You will be shown some practical examples that illustrate the concept
+-   You will be asked to write your own code that uses the concept to solve a small problem
+-   I will show you how I solved the same problem
+
+
+## Working with Jupyter
+
+Python is a very popular programming language for Machine Learning, and it is what we will use in this training.
+
+When dealing with heavier computations, the Python code is usually placed in a `.py` file which is then executed as a whole. In a prototyping or teaching situation, though, it is best to do things more interactively, which is why we will use [Jupyter](https://jupyter.org/) notebooks via `JupyterLab` to arrange our code.
+
+During the first session, we will cover three ways of running Jupyter, but we will only use one during the training (as much as possible):
+
+
+### Jupyter on Habrok
+
+For this training, we recommend using the University of Groningen's High Performance Computing (HPC) cluster, **Habrok**. This ensures everyone has access to the same computational resources and hardware.
+
+**NOTE**:
+
+> You need to have a University of Groningen account to use Habrok. Your account also needs to be enable on Habrok, which you can request by following the [info](https://wiki.hpc.rug.nl/habrok/introduction/policies) on the wiki.
+
+
+### Jupyter locally
+
+If you don't have a University account, or prefer to run things locally on your computer, you will need to install Jupyter (and Python) locally. We give a few pointers on how to do this, but it depends on the operating system you work with, so we do not go into details.
+
+
+### Jupyter in Google
+
+If neither of the above options is workable for you, you can use [Google Colab](https://colab.google/), which is an online platform provided by Google to run Jupyter. Although this is easy to set up and requires minimum configuration, we do not recommend it for long-term usage.

Syllabus.md

@@ -136,87 +136,107 @@
 -   Kernel Trick
 
 
-# Session 4: Ensemble Methods
+# Session 4: Unsupervised Learning - Clustering and Dimensionality Reduction
 
 
-## Introduction to Ensemble Methods
+## Introduction to Unsupervised Learning
 
--   What are Ensemble Methods?
--   Why Use Ensemble Methods?
--   Types of Ensemble Methods
+-   Supervised vs Unsupervised
+-   Dimensionality Reduction
+-   Clustering
+-   Anomaly Detection
 
 
-## Bagging and Random Forests
+## Dimensionality Reduction
 
--   Bagging (Bootstrap Aggregating) Overview
--   Random Forests
--   Feature Importance in Random Forests
+-   Curse of Dimensionality
+-   Principal Component Analysis (PCA)
+-   Choosing the number of components
+-   Linear Discriminant Analysis (LDA)
+-   t-SNE and UMAP (Visualization techniques)
 
 
-## Boosting
+## Clustering
 
--   Boosting Overview
--   AdaBoost
--   Gradient Boosting
--   XGBoost
+-   k-Means Clustering
+-   Elbow Method and Silhouette Score
+-   Hierarchical Clustering (Dendrograms)
+-   DBSCAN (Density-based clustering)
 
 
-## Ensembles of Ensembles
+## Anomaly Detection
 
--   Stacking
--   Multi-level EoE
+-   Isolation Forests
 
 
-# Session 5: Unsupervised Learning - Clustering and Dimensionality Reduction
+# Session 5: Neural Networks I - Foundations and Optimization
 
 
-## Introduction to Unsupervised Learning
+## Introduction to Artificial Neural Networks
 
--   Dimensionality Reduction
--   Clustering
--   Anomaly Detection
+-   Biological Inspiration
+-   The Perceptron Model
+-   Limitations of the Perceptron (XOR problem)
 
 
-## Dimensionality Reduction
+## The Multilayer Perceptron (MLP)
 
--   Principal Component Analysis (PCA)
--   Autoencoders
--   Linear Discriminant Analysis (LDA)
+-   Input, Hidden, and Output Layers
+-   Activation Functions (Sigmoid, Tanh, ReLU, Softmax)
+-   Forward Propagation (Matrix notation)
 
 
-## Clustering
+## Training Neural Networks
 
--   k-Means Clustering
--   Hierarchical Clustering
+-   Loss Functions (MSE vs. Cross-Entropy)
+-   Gradient Descent and Stochastic Gradient Descent (SGD)
+-   Backpropagation intuition
+-   The Vanishing Gradient Problem
 
 
-## Anomaly Detection
+## Optimizing Neural Networks
 
+-   Weight Initialization strategies
+-   Optimizers (Momentum, RMSProp, Adam)
+-   Regularization (Dropout, Batch Normalization, Early Stopping)
 
-# Session 6: Artificial Neural Networks and Deep Learning
 
+## Building a Network in PyTorch/TensorFlow
 
-## Introduction to Neural Networks
+-   Tensors and Operations
+-   Defining a simple architecture
+-   The Training Loop
 
--   What are Neural Networks?
--   Biological Inspiration
--   Structure of a Neural Network
--   Activation Functions
 
+# Session 6: Neural Networks II - Deep Learning, Transformers, and GenAI
 
-## Training Neural Networks
 
--   Forward Propagation
--   Backpropagation
--   Loss Functions
--   Gradient Descent
+## Convolutional Neural Networks (CNNs)
+
+-   Convolution and Pooling Layers
+-   Padding and Stride
+-   Common Architectures (VGG, ResNet)
+
+
+## From RNNs to Transformers
+
+-   Recurrent Neural Networks (RNNs) and LSTMs
+-   The bottleneck of sequential processing
+-   The Attention Mechanism
+-   The Transformer Architecture (Encoder-Decoder)
+
+
+## Large Language Models (LLMs)
+
+-   Evolution of LLMs (BERT, GPT, Llama)
+-   Pre-training, Fine-tuning, and Inference
+-   Tokenization and Context Windows
+-   Prompt Engineering basics
 
 
-## Deep Learning
+## Generative AI and Modern Applications
 
--   What is Deep Learning?
--   Deep Neural Networks
--   Convolutional Neural Networks (CNNs)
--   Recurrent Neural Networks (RNNs)
--   Autoencoders
--   Generative Adversarial Networks (GANs)
+-   Text Generation (Next-token prediction)
+-   Retrieval-Augmented Generation (RAG)
+-   Introduction to Diffusion Models (Image Generation)
+-   Ethical considerations and Bias in GenAI