Introduction au Machine Learning

Découvrir les différents types de modèles et algorithmes d'apprentissage automatique

Les modèles et les algorithmes

Découvrez les différents types de Modèles:

Nature des données et contexte: tabulaire, texte, sons, image, vidéo, séries temporelles: le ML s’applique à tout type de données => liste d’exemples. Les principaux modèles de ML: de LR (GLM) à NN/DL en passant par Tree-based; Pertinence en fonction du type et volume de données et aussi de leurs propriétés statistiques; dicte le choix des modèles et des outils. On distingue GLM,Tree et NN. Tableau comparatif.

Même si vous vous limitez au contexte supervisé tel qu’exposé au chapitre précédent, vous vous retrouverez en face d’une multitude de modèles, chacun possédant des caractéristiques propres et des performances escomptées.

La documentation de sklearn pour l’apprentissage supervisé est un bon exemple de cette richesse de choix. https://scikit-learn.org/stable/supervised_learning.html#supervised-learning

Ne pouvant tous les tester un par un, vous aller donc devoir choisir rapidement comment vous équiper pour la tâche à venir.

En règle générale, vous choisirez le modèle en fonction du contexte et du cahier des charges.

Le schéma suivant est extrait de la documentation de scikit-learn. Bien qu’un peu daté, il résume le processus de choix d’un modele.

Cependant, pour vous faire gagner du temps, on distingue après 2020:

Les autres types de modèles bien qu’adaptés dans certains contexte, n’offriront pas la versatilité et la robustesse ce cette short liste. Ils sont devenu obsoletes alors que d’autres emergeaient comme plus puissant. C’est le cas par exemples des SVMs, elegants mathematiquement mais peu competitifs face a XGBoost.

Depuis quelques années, XGBoost est le grand vainqueur des compétitions Kaggle et des concours de modélisation. C’est un modèle qui a fait ses preuves.

Sachez définir un modèle

Fixer les idées: Modélisation ou modèle. distinguer le type de modèle du modèle entraîné sur un jeu de donnée particulier dans un but particulier. parallèle avec la classe et l’instance en programmation.

Mais qu’est ce qu’un modele de Machine learning ? De quoi parle-t on au final quand on parle de modele ?

On va distinguer

En python on importe le modele

from sklearn.ensemble import RandomForestClassifier

En python cela consiste à utiliser la methode fit. Par exemple:

from sklearn.ensemble import RandomForestClassifier
X = [[0, 0], [1, 1]]
Y = [0, 1]
clf = RandomForestClassifier(n_estimators=10)
clf = clf.fit(X, Y)

dans ce code, clf est le modele entraîné sur les données X et Y. RandomForestClassifier est le type de modèle.

Par soucis de simplcité on parle dans les 2 cas du modèle.

Sachez définir un algorithme

Définir ce qu’est un algo, illustrer avec l’algo pour calculer \sqrt(2). donner le code. Faire le lien avec le ML; mentionner le gradient stochastique

Nous avons donc un modele entrainé sur des données. Mais comment se passe cette entrainement ?

Nous ne rentrerons pas ici dans le arcanes des algorithmes d’entrainement, procédures ultra-optimisées en C, cela serait hors sujet pour ce cours. Mais je voudrais illustrer par un exemple, ce qu’est un algorithme. Ce quipermettra de faire jaillir une notion fondamentale du machine learning: l’erreur d’estimation!

La définition officielle d’uin algorithme: Un algorithme est une série d’instruction définies et ordonnées qui permettent d’effectuer une tâche spécifique, un calcul par exemple.

Prenons donc un exemple simple avec le calcul de la racine de 2. Sans utiliser une calculatrice, nous pouvons calculer la racine de 2 par une série de calculs plus simples.

On aboutit en quelqeus itérations à une bonne approximation du résultat escompté.

Pour cela, nous allons utiliser la méthode de Héron dite méthode babylonienne, inventée au 1er siècle apres JC par les babyloniens. La science des algorithmes ne date pas d’hier. Excellente méthode efficace d’extraction de racine carrée (ou plus d’ailleurs)!

Partons d’une valeur candidate (x = 1) et mettons à jour cette valeur jusqu’a ce que le résultat soit assez proche du résultat attendu. On saura simplement si x est proche de la racine carrée de 2 si x^2 est proche de 2.

Voici donc l’agorithme de Héron pour le calcul des racines carrées

Tant que |x^2 - 2| > precision : x = (x + 2/x)/2

En python, cela s’ecrit

x = 1
precision = 0.001
while (abs(x**2 - 2) > precision) :
    x = (x + 2/x)/2

print(x)

Cet algorithme est extrêmenent efficace. En seulement trois étapes, la précision relative sur la valeur de √2 est déjà de 10–6, ce qui est excellent, et de moins de 10^{–12} en quatre étapes.

Remarquez maintenant la quantite |x^2 - 2| que nous avons calculé à chaque itération: la différence en valeur absolu entre la valeur candidate au carré et 2. C’est l’erreur d’estimation entre la valeur candidate, notre valeur estimée et la valeur dite de vérité (groundtruth en anglais)

On peut réecrire l’algo en mettant en avant cette erreur d’estimation

x = 1
erreur = 1
precision = 0.001

Tant que erreur > precision:
    # maj de l'estimation
    x = (x + 2/x)/2
    # maj de l'erreur avec la nouvelle valeur de x
    erreur = |x^2 - 2|

soit en python

x = 1
error = 1
precision = 0.001

while error > precision:
    # Update the estimation
    x = (x + 2/x) / 2
    # Update the error with the new value of x
    error = abs(x**2 - 2)

print(f"Approximation of √2: {x}")
print(f"Final error: {error}")
print(f"Actual √2: {2**0.5}")
print(f"Difference: {abs(x - 2**0.5)}")

Voila, dans ce simple algorithme qui date de 2000 ans, nous avons les composantes principales d’un algorithme de machine learning

Note: au lieu de calculer la valeur absolu de l’erreur d’estimation, nous aurions put aussi prendre son carrée

Dans ce cas, nous aurions eu l’algorithme suivant

Tant que erreur > precision:
    # maj de l'estimation
    x = (x + 2/x)/2
    # maj de l'erreur avec la nouvelle valeur de x
    erreur = (x^2 - 2)^2

La question est alors de savoir si ce critère fait converger plus ou moins rapidement l’estimation de la racine de 2. Qu’en pensez vous?

gradient stochastique

Le principal algorithme qui sert à entrainer la plupart des modèles de ML, deep learning inclus, s’appelle le gradient stochastique. Sans rentrer dans les details, le GS fonctionne comme l’algo de Héron .

Soit un jeux d’echantillons. On cherche a estimer un vecteur h qui minimise un critère, une fonction de coût.

On se dote d’un paramètre essentiel, le learning rate souvent noté \alpha et aussi appelé taux d’apprentissage, qui va permettre d’adapter la correction de l’estimation en fonction de l’erreur d’estimation.

On aura de façon simplifié à chaque itération:

calcul de l'erreur = f(estimation)
maj de l'estimation = estimation * \alpha * f(erreur)
stop en fonction de l'erreur

En pratique, étant donné un jeu de donné, cela donne:

En pratique, le parametre \alpha sert à regler la rapidite de convergence de l’algorithme et la precision des resultats. C’est le taux d’apprentissage / learning rate.

C’est un des parametres principal des modeles que vous serez amené a entrainer.

Mise en pratique

Illustration de l’influence du learning rate sur la vitesse de convergence

Tout d’abord importer les librairies python

import matplotlib.pyplot as plt
import numpy as np
import math

Voici une definition complete de la function de l’algorithme appelé Newton-Raphson

La fonction retourne la series de erreurs successives en log.


def sqrt2(x, error, precision, learning_rate):
    """
    Calculate square root of 2 using Newton-Raphson method with learning rate.
    Logs the natural logarithm of error values at each iteration.

    Parameters:
    x (float): Initial estimation
    error (float): Initial error value
    precision (float): Precision threshold to stop iteration
    learning_rate (float): Learning rate to control update step

    Returns:
    list: log(error) values at each iteration
    """
    log_errors = []
    iterations = 0

    while error > precision:
        # Calculate the Newton-Raphson update
        x_new = (x + 2/x) / 2
        # Apply learning rate to control the update step
        x = x + learning_rate * (x_new - x)
        # Update the error with the new value of x
        error = abs(x**2 - 2)
        log_errors.append(math.log(error))
        iterations += 1

        if iterations > 10000:  # safety check
            print("Warning: Maximum iterations reached")
            break

    return log_errors

On peut ensuite jouer avec differentes valeur de learning rate

# Define a colorblind-friendly colormap
colors = plt.cm.viridis(np.linspace(0, 1, len([0.001, 0.01, 0.1, 0.5])))

for i, lr in enumerate([0.001 0.01, 0.1, 0.5]):
    err = sqrt2(1, 1, 0.001, lr)

    plt.plot(err, label=f'LR = {lr}, nitr ={len(err)} ', color=colors[i])

plt.xlabel('Iterations')
plt.ylabel('log(Error)')
plt.title('Convergence of sqrt(2) using Newton-Raphson with different Learning Rates')
plt.legend()
plt.grid(True)
plt.show()

Cela donne la figure suivante

figure

ou nitr correspond au nombre d’itération nécessaire pour converger, atteindre la précision souhaitée.

ce qu’il faut retenir:

Accroitre la valeur du learning rate permet de converger plus vite

Recapitulatif

Voici un récapitulatif des points clés de ce chapitre sur les modèles et algorithmes :

Classification des modèles ML

Distinction modèle vs instance

Concepts algorithmiques fondamentaux

Gradient stochastique - moteur du ML

Règle pratique