Apprentissage automatique pour les ingénieurs logiciels

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 "sqft", "num_rooms", 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écouvrez donc comment trouver ces poids.

Trouver les poids

Le processus de recherche des 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 poids, nous devons savoir à quel point nos prédictions sont fausses. 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 de dégradé

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 dénivelé, on fait 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 poids en déplaçant 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 dégradé 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 bain).
  • 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 de 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 < original_error, le dégradé est négatif, ce qui signifie qu'augmenter ce poids diminue l'erreur.

• La magnitude 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.

This is called "numerical gradient calculation" or "finite difference method". We're approximating the gradient instead of calculating it analytically.

Let's update the weights

Now that we have our gradients, we can push our weights in the opposite direction of the gradient by subtracting the gradient.

weights[i] -= gradients[i]

If our gradient is too large, we could easily overshoot our minimum by updating our weight too much. To fix this, we can multiply the gradient by some small number:

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

And so here is how we do it for all of the weights:

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

Finally, we have our weights!

Interpreting the Model

Once we have our trained weights, we can use them to interpret our model:

• The weight for 'sqft' represents the price increase per square foot.
• The weight for 'bedrooms' represents the price increase per additional bedroom.
• The weight for 'baths' represents the price increase per additional bathroom.

For example, if our trained weights are [100, 10000, 15000], it means:

• Each square foot adds $100 to the home price.
• Each bedroom adds $10,000 to the home price.
• Each bathroom adds $15,000 to the home price.

Linear models, despite their simplicity, are powerful tools in machine learning. They provide a foundation for understanding more complex algorithms and offer interpretable insights into real-world problems.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!