Artificial Intelligence (AI) promises us that, provided we have large amounts of relevant data (text, images, sales details, website click events, ...) available, it can build a model from it. A model is a simplified representation of reality that allows us describe, explain, and even predict phenomena. Actually, the model detected re-occurring "patterns" in the data, or more specifically relationships between the data "features". So it can now "guess" (or predict) a target feature (next word, pixel, per-product sales prognosis, break-in attempt, ...) from the rest of the data, e.g. generate new texts and images or trigger alarms.

The semi-automated process of training (i.e.: learning) and making available AI models is called Machine Learning (ML):

• First, relevant data must be collected, and organized in so-called Data Frames.
• Then, the data is passed through a set of standard, established ML algorithms to build a first version of the data model.
• Next, the model should be evaluated to ensure it performs well on unseen validation data, i.e.: to minimize prediction error.
• A suboptimal model needs to be improved by starting over: adding new data sources, applying other ML algorithms, changing algorithm parameters, ...
  This can of course be a highly time consuming (but largely automatic) process, depending on the size of your training data.
• It might help to visualize the data, in order to help this process (like selecting data features, algorithms, or parameters).
• When ready (and promising), the model can now be deployed outside the ML setup, for prediction, explanation, or decision-making.
  (A "running" model is relatively lightweight, and can continuously generate predictions on new incoming data.)

This process applies across disciplines, from physics and economics to image processing and language.

Established machine learning algorithms have been developed over the past decades, and were implemented in several languages. Today, Python, and more specifically packages like scikit-learn and PyTorch are very popular and user-friendly front-ends to this large collection of available algorithms. Data in any (file) format can easily be loaded into a Python (Pandas) Data Frame, split into training and validation data, and passed though the building and evaluation process. Python also easily allows to visualize a Data Frame.

One of the simplest and most fundamental machine learning models is linear regression. This model assumes that the relationship between input features and target feature can be expressed as a weighted sum of the inputs. Training a linear regression model means finding the weights that minimize the prediction error. Although often too simplistic on its own, linear regression is crucial as a building block: more advanced models often use it internally since its modelling is fast, and moreover it tends to avoid overfitting to the training data (which would make models less predictive on new, unseen data).

Artificial neural networks extend the logic of linear regression into a far more flexible and powerful framework. Inspired by biological neurons, these models consist of layers of interconnected nodes, each of which processes inputs through a weighted sum and a nonlinear activation function. Hidden layers transform the input into increasingly abstract representations, allowing the network to capture complex, nonlinear relationships. Neural networks perform so-called deep learning, and provide the foundation for much of modern artificial intelligence.

Neural networks can be built in Python with e.g. the PyTorch package. The process of building and evaluating them is of course more time and memory consuming, but promises remarkably good results, especially in the areas of image processing (e.g. surveillance camera data) and natural language processing (NLP), with so-called large language models (LLMs).

• This course will get you started with the elementary practical aspects of Artificial Intelligence (AI) and Machine Learning (ML).
• The essential steps in the ML process will be covered in detail: obtaining and organizing data, selecting a model family, training the model, validating its quality, finding optimal model parameters, and possibly starting over by selecting additional data.
• We will put this knowledge into practice by building (and using) our own machine learning models in Python with scikit-learn, a popular library for ML.
• We'll also briefly look into neural networks, and the Python package PyTorch.

• Overview of the data pipeline process for creating and deploying AI models.
• Basic concepts & techniques in AI and Machine Learning:
  • Supervised learning versus unsupervised learning
  • Training & testing data; cross-validation
  • Accuracy; confusion matrix
  • Under-fitting versus over-fitting; the bias–variance trade-off
  • Regularisation
  • Automating the model selection process: validation curves
• The different model types to be trained with Machine Learning:
  • Predicting a continuous feature: e.g. polynomial regression, Ridge regression
  • Classification: e.g. logistic regression, anomaly detection, decision trees, random forests
  • Clustering: e.g. K-means
  • Dimensionality reduction: PCA & LDA
  • A short introduction into neural networks and deep learning
• Building, validating and using Machine Learning models with scikit-learn

Classroom teaching, focused on practical examples and supported by in-depth exercises and individual practice.

Delivered as a live, interactive training – available in-person or online, or in a hybrid format. Training can be implemented in English, Dutch, or French.

Good knowledge of the Python programming language is a prerequisite (see Python fundamentals). Knowledge of Pandas (see course Python for data analytics) and of Jupyter Notebook is an advantage.

Anyone that needs the hands-on with machine learning to solve real-life problems.