Faites-moi savoir si vous trouvez cela utile et je continuerai !

Chapitre 1 - Le modèle linéaire

L'un des concepts les plus simples mais puissants est le modèle linéaire.

En ML, l'un de nos principaux objectifs est de faire des prédictions basées sur des données. Le modèle linéaire est comme le « Hello World » de l'apprentissage automatique : il est simple mais constitue la base de la compréhension de modèles plus complexes.

Construisons un modèle pour prédire les prix des logements. Dans cet exemple, le résultat est le « prix de la maison » attendu et vos entrées seront des éléments tels que « pied carré », « num_chambres », etc...

def prediction(sqft, num_bedrooms, num_baths):
    weight_1, weight_2, weight_3 = .0, .0, .0  
    home_price = weight_1*sqft, weight_2*num_bedrooms, weight_3*num_baths
    return home_price

Vous remarquerez un "poids" pour chaque entrée. Ce sont ces poids qui créent la magie derrière la prédiction. Cet exemple est ennuyeux car il produira toujours zéro puisque les poids sont nuls.

Découvrons donc comment trouver ces poids.

Trouver les poids

Le processus permettant de trouver les poids est appelé « entraînement » du modèle.

• Tout d'abord, nous avons besoin d'un ensemble de données de maisons avec des caractéristiques (entrées) et des prix (sorties) connus. Par exemple:

data = [
    {"sqft": 1000, "bedrooms": 2, "baths": 1, "price": 200000},
    {"sqft": 1500, "bedrooms": 3, "baths": 2, "price": 300000},
    # ... more data points ...
]

• Avant de créer un moyen de mettre à jour nos pondérations, nous devons savoir à quel point nos prévisions sont erronées. Nous pouvons calculer la différence entre notre prédiction et la valeur réelle.

home_price = prediction(1000, 2, 1) # our weights are currently zero, so this is zero
actual_value = 200000

error = home_price - actual_value # 0 - 200000 we are way off. 
# let's square this value so we aren't dealing with negatives
error = home_price**2

Maintenant que nous avons un moyen de savoir à quel point nous sommes en erreur pour un point de données, nous pouvons calculer l'erreur moyenne sur tous les points de données. C’est ce qu’on appelle communément l’erreur quadratique moyenne.

• Enfin, mettez à jour les poids de manière à réduire l'erreur quadratique moyenne.

Nous pourrions, bien sûr, choisir des nombres aléatoires et continuer à économiser la meilleure valeur au fur et à mesure, mais cela est inefficace. Explorons donc une méthode différente : la descente de gradient.

Descente graduelle

La descente de gradient est un algorithme d'optimisation utilisé pour trouver les meilleurs poids pour notre modèle.

Le dégradé est un vecteur qui nous indique comment l'erreur change à mesure que nous apportons de petites modifications à chaque poids.

Intuition de la barre latérale
Imaginez-vous debout dans un paysage vallonné et votre objectif est d'atteindre le point le plus bas (l'erreur minimale). La pente est comme une boussole qui indique toujours la montée la plus raide. En allant à contre-sens du gradient, nous faisons des pas vers le point le plus bas.

Voici comment cela fonctionne:

1. Commencez avec des poids aléatoires (ou des zéros).
2. Calculez l'erreur pour les poids actuels.
3. Calculez le gradient (pente) de l'erreur pour chaque poids.
4. Mettez à jour les pondérations en effectuant un petit pas dans la direction qui réduit l'erreur.
5. Répétez les étapes 2 à 4 jusqu'à ce que l'erreur cesse de diminuer de manière significative.

Comment calculer le gradient pour chaque erreur ?

Une façon de calculer le gradient consiste à effectuer de petits changements dans le poids, à voir comment cela a impacté notre erreur et à voir où nous devrions aller à partir de là.

def calculate_gradient(weight, data, feature_index, step_size=1e-5):
    original_error = calculate_mean_squared_error(weight, data)

    # Slightly increase the weight
    weight[feature_index]  = step_size
    new_error = calculate_mean_squared_error(weight, data)

    # Calculate the slope
    gradient = (new_error - original_error) / step_size

    # Reset the weight
    weight[feature_index] -= step_size

    return gradient

Répartition étape par étape

• Paramètres d'entrée:

  • poids : l'ensemble actuel de poids pour notre modèle.
  • data : Notre ensemble de données sur les caractéristiques et les prix des maisons.
  • feature_index : Le poids pour lequel nous calculons le dégradé (0 pour le pied carré, 1 pour les chambres, 2 pour les salles de bains).
  • step_size : Une petite valeur que nous utilisons pour modifier légèrement le poids (la valeur par défaut est 1e-5 ou 0,00001).

• Calculer l'erreur d'origine :
  
  

   original_error = calculate_mean_squared_error(weight, data)

Nous calculons d'abord l'erreur quadratique moyenne avec nos poids actuels. Cela nous donne notre point de départ.

• Augmentez légèrement le poids :

   weight[feature_index]  = step_size

Nous augmentons le poids d'une petite quantité (step_size). Cela nous permet de voir comment un petit changement dans le poids affecte notre erreur.

• Calculer une nouvelle erreur :

   new_error = calculate_mean_squared_error(weight, data)

Nous calculons à nouveau l'erreur quadratique moyenne avec le poids légèrement augmenté.

• Calculer la pente (dégradé) :

   gradient = (new_error - original_error) / step_size

C'est l'étape clé. Nous demandons : « Dans quelle mesure l’erreur a-t-elle changé lorsque nous avons légèrement augmenté le poids ? »

• Si new_error > original_error, le gradient est positif, ce qui signifie que l'augmentation de ce poids augmente l'erreur.
• Si new_error

• L'ampleur nous indique à quel point l'erreur est sensible aux changements de ce poids.

  • Réinitialiser le poids :

   weight[feature_index] -= step_size

Nous avons remis le poids à sa valeur d'origine puisque nous testions ce qui se passerait si nous le modifiions.

• Renvoyer le dégradé :

   return gradient

Nous renvoyons le gradient calculé pour ce poids.

C'est ce qu'on appelle le « calcul du gradient numérique » ou la « méthode des différences finies ». Nous approchons le gradient au lieu de le calculer analytiquement.

Mettons à jour les poids

Maintenant que nous avons nos dégradés, nous pouvons pousser nos poids dans la direction opposée du dégradé en soustrayant le dégradé.

weights[i] -= gradients[i]

Si notre gradient est trop important, nous pourrions facilement dépasser notre minimum en mettant trop à jour notre poids. Pour résoudre ce problème, nous pouvons multiplier le dégradé par un petit nombre :

learning_rate = 0.00001
weights[i] -= learning_rate*gradients[i]

Voici donc comment procéder pour tous les poids :

def gradient_descent(data, learning_rate=0.00001, num_iterations=1000):
    weights = [0, 0, 0]  # Start with zero weights

    for _ in range(num_iterations):
        gradients = [
            calculate_gradient(weights, data, 0), # sqft
            calculate_gradient(weights, data, 1), # bedrooms
            calculate_gradient(weights, data, 2)  # bathrooms
        ]

        # Update each weight
        for i in range(3):
            weights[i] -= learning_rate * gradients[i]

        if _ % 100 == 0:
            error = calculate_mean_squared_error(weights, data)
            print(f"Iteration {_}, Error: {error}, Weights: {weights}")

    return weights

Enfin, nous avons nos poids !

Interprétation du modèle

Une fois que nous avons nos poids entraînés, nous pouvons les utiliser pour interpréter notre modèle :

• Le poids pour « pied carré » représente l'augmentation du prix par pied carré.
• Le poids pour les « chambres » représente l'augmentation du prix par chambre supplémentaire.
• Le poids pour les « baignoires » représente l'augmentation du prix par salle de bain supplémentaire.

Par exemple, si nos poids entraînés sont [100, 10 000, 15 000], cela signifie :

• Chaque pied carré ajoute 100 $ au prix de la maison.
• Chaque chambre ajoute 10 000 $ au prix de la maison.
• Chaque salle de bain ajoute 15 000 $ au prix de la maison.

Les modèles linéaires, malgré leur simplicité, sont des outils puissants en apprentissage automatique. Ils fournissent une base pour comprendre des algorithmes plus complexes et offrent des informations interprétables sur des problèmes du monde réel.