Artificial Intelligence#
Course path#
The goal of this course is not to begin with a long theoretical introduction to artificial intelligence.
Let’s move quickly into practice and progressively understand what makes a classical program different from a system that learns from data.
The progression builds on existing programming knowledge and focuses on concrete examples.
1. From a few variables to first data#
This first step starts with a classical program and progressively reaches data associated with an expected result.
From a few variables to our first data
2. A first model that learns its weights#
We move from a threshold calculated from examples to a model that learns weights and a bias in order to perform classification.
A first model that learns its weights
3. Understanding gradient descent#
Understand how a loss function and a gradient can progressively guide the modification of a model’s parameters.
Let’s start from a deliberately simple problem with a single weight to understand the mechanism before returning to more complex models.
Gradient Descent: Learning by Correcting
4. From learning to prediction#
Apply gradient descent to our watering model with several parameters and discover the limits of a simple score.
We look in particular at the effect of data scale, normalization, and the transition between the score produced by the model and an actionable decision.
5. From the sigmoid to the first neuron#
Transform our model’s score into a continuous output between 0 and 1, then combine inputs, weights, bias, score, and an activation function to build our first artificial neuron.
From the Sigmoid to the First Neuron
6. Several Neurons, Why?#
Understand why a single neuron is not always enough and build our first small neural network.
7. Discovering Deep Learning#
Understand why Deep Learning methods can handle much more complex problems and how they extend the principles studied previously.
8. Computer vision#
Use artificial intelligence to work with images and discover the principles of computer vision.
The goal will progressively be to connect:
camera → image → model → interpretation
9. LLMs and local generative artificial intelligence#
Discover the general principles behind large language models and understand what is required to run models locally.
We will cover the constraints related to:
- hardware resources;
- memory;
- models;
- local inference.
10. Running a model on the Arduino UNO Q#
Return to embedded applications and progressively put the concepts studied on the UNO Q into practice.
The objective is to move from:
classical program → learned model → embedded intelligence
Technologies used#
Throughout the course, we will use in particular:
- Python;
- NumPy;
- scikit-learn;
- neural networks;
- TensorFlow or PyTorch;
- computer vision tools;
- language models;
- embedded optimization techniques.
Python programming will be limited to what is necessary to work with AI. The main objective remains to understand how to move from an explicitly programmed system to a system capable of learning from data.
Another path: AI Agents#
A model can produce an answer. An agent goes further: it uses tools to observe an environment and perform an action within a controlled scope.
This parallel path starts from concrete experiments to progressively explore technical identity, permissions, authentication, safeguards, traceability, and the role of human validation.