Tu entends parler d'intelligence artificielle partout : ChatGPT, recommandations Netflix, voitures autonomes... Mais en NSI, l'IA n'est pas de la magie : c'est de l'algorithmique et des mathématiques appliquées. Au programme de Première et de Terminale, tu vas coder toi-même des algorithmes d'apprentissage. Pas besoin d'être un génie : il faut juste comprendre la logique et savoir écrire du Python propre. Dans cet article, on décortique l'intelligence artificielle en NSI et le machine learning au lycée, avec du code testable et une méthode de révision efficace.
Qu'est-ce que l'intelligence artificielle en NSI ?
D'abord, distinguons trois termes souvent confondus.
- Intelligence artificielle (IA) : domaine qui cherche à faire réaliser à une machine des tâches qui demandent normalement de l'intelligence humaine (jouer aux échecs, reconnaître une image, traduire un texte).
- Machine learning (apprentissage automatique) : sous-domaine de l'IA où la machine apprend à partir de données au lieu d'être programmée règle par règle.
- Deep learning : machine learning basé sur des réseaux de neurones profonds (hors programme NSI, mais tu croiseras le terme).
En NSI, on se concentre sur le machine learning, et plus précisément sur deux grandes familles :
- Apprentissage supervisé : on fournit des exemples étiquetés (entrée → sortie attendue) et l'algorithme apprend à prédire. Exemple : reconnaître un chiffre manuscrit.
- Apprentissage non supervisé : on fournit des données sans étiquette et l'algorithme cherche des groupes (clustering). Exemple : regrouper des clients similaires.
Le programme officiel de Terminale NSI cite explicitement l'algorithme des k plus proches voisins (k-NN) et la classification. C'est ton terrain de jeu principal. Si tu veux revoir les bases algorithmiques avant de te lancer, jette un œil à nos cours NSI.
Pourquoi parle-t-on de "données d'entraînement" ?
Un algorithme de machine learning ne "comprend" rien : il trouve des régularités statistiques dans un jeu de données. On sépare souvent les données en deux :
- Données d'entraînement : celles que l'algorithme utilise pour apprendre.
- Données de test : celles qu'on garde de côté pour vérifier que l'algorithme généralise bien (et ne fait pas du "par cœur").
Cette séparation est fondamentale : un algorithme qui réussit sur les données d'entraînement mais échoue sur les données de test est en surapprentissage (overfitting).
L'algorithme des k plus proches voisins en Python
Le k-NN est l'algorithme d'IA le plus simple à comprendre et à coder. Principe : pour classer un nouveau point, on regarde les k points les plus proches dans les données d'entraînement, et on prend la classe majoritaire.
Étape 1 : calculer une distance
On utilise souvent la distance euclidienne. Pour deux points a et b en 2D :
import math
def distance(a, b):
"""Distance euclidienne entre deux points (tuples)."""
return math.sqrt((a[0] - b[0])**2 + (a[1] - b[1])**2)
# Exemple
d = distance((0, 0), (3, 4))
print(d) # 5.0Étape 2 : trouver les k plus proches voisins
def k_plus_proches(donnees, point, k):
"""Renvoie les k points de 'donnees' les plus proches de 'point'.
'donnees' est une liste de tuples (x, y, etiquette)."""
# On calcule la distance pour chaque point
distances = []
for d in donnees:
dist = distance((d[0], d[1]), point)
distances.append((dist, d))
# On trie par distance croissante
distances.sort(key=lambda t: t[0])
# On garde les k premiers
return [d for _, d in distances[:k]]Étape 3 : voter pour la classe majoritaire
def classe_majoritaire(voisins):
"""Renvoie l'etiquette la plus frequente parmi les voisins."""
compteur = {}
for v in voisins:
etiquette = v[2]
compteur[etiquette] = compteur.get(etiquette, 0) + 1
# On cherche l'etiquette avec le plus grand compteur
return max(compteur, key=compteur.get)
def predire(donnees, point, k=3):
voisins = k_plus_proches(donnees, point, k)
return classe_majoritaire(voisins)Étape 4 : tester sur un mini-jeu de données
# Donnees : (x, y, etiquette)
donnees = [
(1, 1, 'A'), (2, 1, 'A'), (1, 2, 'A'),
(6, 6, 'B'), (7, 6, 'B'), (6, 7, 'B'),
]
print(predire(donnees, (2, 2), k=3)) # A
print(predire(donnees, (6, 5), k=3)) # B
print(predire(donnees, (4, 4), k=3)) # depend du kBravo, tu viens d'écrire un classifieur supervisé ! C'est exactement le type d'algorithme attendu en NSI. Entraîne-toi sur nos exercices NSI pour automatiser ces manipulations.
Cas d'usage concret : classer des fleurs avec des données
Le jeu de données Iris est un classique : 150 fleurs décrites par 4 mesures (longueur et largeur des pétales et sépales), réparties en 3 espèces. Tu peux le charger en Python depuis un fichier CSV, puis appliquer ton k-NN.
import csv
def charger_iris(fichier):
donnees = []
with open(fichier, newline='') as f:
lecteur = csv.reader(f)
next(lecteur) # sauter l'en-tete
for ligne in lecteur:
# 4 mesures + etiquette
x = float(ligne[0])
y = float(ligne[1])
etiquette = ligne[4]
donnees.append((x, y, etiquette))
return donneesEnsuite, tu sépares aléatoirement 80 % pour l'entraînement et 20 % pour le test. Tu comptes combien de prédictions sont correctes : c'est le taux de bonne classification. Un bon classifieur dépasse souvent 90 % sur Iris. Cette démarche (séparer, entraîner, évaluer) est la base de tout projet de machine learning.
Astuce : si tu veux aller plus loin en mathématiques ou en sciences, le réseau Allo Lycée propose des ressources complémentaires utiles pour consolider les bases. Et pour préparer l'oral ou l'écrit du bac, Allo Bac regroupe des fiches méthodologiques.
Et le lien avec SQL ?
En pratique, les données d'entraînement viennent souvent de bases de données. Savoir interroger une base avec SQL est donc un vrai plus : tu peux extraire, filtrer et préparer tes données avant de les passer à ton algorithme. Va voir notre page cours SQL pour maîtriser SELECT, WHERE et JOIN.
Méthode de révision et lien avec l'épreuve du bac NSI
L'IA et le machine learning tombent régulièrement à l'épreuve écrite et à l'épreuve pratique. Voici une méthode en 5 étapes pour ne rien laisser au hasard.
1. Maîtrise le vocabulaire
Sache définir sans hésiter : apprentissage supervisé, non supervisé, données d'entraînement, données de test, surapprentissage, classification, clustering. Une question de cours peut tomber telle quelle.
2. Code le k-NN de mémoire
Écris la fonction distance, puis k_plus_proches, puis predire. Refais-le trois fois sans regarder. C'est le meilleur moyen d'être prêt pour l'épreuve pratique.
3. Analyse des résultats
Sache expliquer pourquoi un taux de bonne classification n'est pas parfait : données bruitées, mauvais choix de k, dimensions trop nombreuses. On attend de toi un regard critique, pas juste du code.
4. Relie l'IA à l'éthique
Le programme NSI insiste sur les enjeux sociétaux : biais algorithmiques, protection des données personnelles (RGPD), impact environnemental de l'entraînement. Prépare 2-3 arguments pour chaque point.
5. Fais des annales
Les sujets des années précédentes contiennent des questions sur l'IA. Chronomètre-toi, puis compare avec le corrigé. Si tu bloques sur un point, reviens à ton cours NSI et refais l'exercice.
Erreurs classiques à éviter
- Confondre
k(nombre de voisins) et le nombre de classes. - Oublier de normaliser les données : une variable en km écrase une variable en mètres.
- Tester sur les données d'entraînement : le résultat est trop optimiste.
- Croire que l'IA "comprend" : elle calcule, elle ne pense pas.
Conclusion : l'IA en NSI, c'est à ta portée
L'intelligence artificielle en NSI n'est ni mystérieuse ni réservée aux experts. En comprenant l'apprentissage supervisé, en codant un k-NN propre en Python et en analysant tes résultats, tu couvres l'essentiel du programme. Le machine learning au lycée, c'est avant tout de la méthode : des données, un algorithme, une évaluation. Continue à coder, à tester, à te tromper, puis à recommencer. Chaque ligne de Python te rapproche de la maîtrise. Allez, ouvre ton éditeur et lance ton premier classifieur !
