first

src/cost_function.py

@@ -0,0 +1,9 @@
+import numpy as np
+
+# Fonction de coût
+def compute_cost(theta_0, theta_1, X, y):
+    m = len(y)
+    predictions = theta_0 + theta_1 * X # calcul des prédictions h(θ)
+    errors = predictions - y # Erreur entre prédictions et vrai prix
+    cost = (1 / (2 * m)) * np.sum(errors **2) # Somme des erreurs quadratiques
+    return cost

src/data_process.py

@@ -0,0 +1,24 @@
+import pandas as pd # Manipulation des données
+from visualization import plot_raw_data
+
+def load_and_process_data(file_path):
+    df = pd.read_csv(file_path)
+    
+    # Nettoyage : Suppression des valeurs manquantes
+    df = df.dropna() # méthode de pandas dropna() pour supprimer les valeurs NaN (NotaNumber) manquantes dans le 
+    # Normailisation Min-Max
+    km_min, km_max = df["km"].min(), df["km"].max()
+    price_min, price_max = df["price"].min(), df["price"].max()
+    
+    df["km_norm"] = (df["km"] - km_min) / (km_max - km_min)
+    df["price_norm"] = (df["price"] - price_min) / (price_max - price_min)
+    
+    df.to_csv("data/data_normalized.csv", index=False)
+    print("Données nettoyées et normalisées suvegardées dans 'data/data_normalized.csv' !")
+    plot_raw_data(df) # Affichage des données normalisées 
+    
+    return df, km_min, km_max, price_min, price_max # Retourne les données normalisées et les bornes de normalisation
+      
+
+if __name__ == "__main__":
+    load_and_process_data("data/data.csv") # Appel de la fonction avec le chemin du fichier de données

src/gradient_descent.py

@@ -0,0 +1,25 @@
+import numpy as np
+from src.cost_function import compute_cost
+
+def gradient_descent(X, y, theta_0, theta_1, learning_rate, iterations):
+    """Applique la descente de gradient et retourne les paramètres optimisés."""
+    m = len(y)
+    cost_history = [] # Historique des coûts pour visualisation
+    
+    for i in range(iterations):
+        predictions = theta_0 + theta_1 * X
+        error = predictions - y
+        
+        d_theta_0 = (1 / m) * np.sum(error)
+        d_theta_1 = (1 / m) * np.sum(error * X)
+        
+        theta_0 -= learning_rate * d_theta_0
+        theta_1 -= learning_rate * d_theta_1
+        
+        cost = compute_cost(theta_0, theta_1, X, y)
+        cost_history.append(cost)
+        
+        if i % 100 == 0:
+            print(f"Iteration {i} : theta_0 = {theta_0}, theta_1 = {theta_1}, cost = {cost}")
+    
+    return theta_0, theta_1, cost_history

src/prediction.py

@@ -0,0 +1,29 @@
+import numpy as np
+import pandas as pd
+
+# Charger les valeurs min/max pour la dé-normalisation
+df = pd.read_csv("data/data_normalized.csv")
+km_min, km_max = df["km"].min(), df["km"].max()
+price_min, price_max = df["price"].min(), df["price"].max()
+
+def predict_price(km):
+    """Prédit le prix d'une voiture en fonction du kilométrage donné en entrée."""
+    # Charger les paramètres optimisés (entraînés sur des données normalisées)
+    theta_0, theta_1 = np.load("model.npy")
+
+    # Normaliser le kilométrage
+    km_norm = (km - km_min) / (km_max - km_min)
+
+    # Calculer le prix normalisé
+    price_norm = theta_0 + theta_1 * km_norm
+
+    # Dé-normaliser le prix pour obtenir un montant en euros
+    price = price_norm * (price_max - price_min) + price_min
+
+    return price
+
+if __name__ == "__main__":
+    km_input = float(input("Entrez un kilométrage : "))
+    price_predicted = predict_price(km_input)
+    print(f"Prix estimé : {price_predicted:.2f} €")
+

src/training_model.py

@@ -0,0 +1,39 @@
+import numpy as np
+import pandas as pd
+from src.data_process import load_and_process_data
+from src.gradient_descent import gradient_descent
+from src.visualization import plot_cost_history, plot_regression_line
+
+def train_model():
+    """
+    Charge les données, entraîne le modèle et sauvegarde les paramètres optimisés.
+    """
+    df, _, _, _, _ = load_and_process_data("data/data.csv")
+    X = df["km_norm"].values
+    y = df["price_norm"].values
+
+    # Paramètres initaux
+    theta_0_init = 0
+    theta_1_init = 1
+    learning_rate = 0.1 # Taux d'apprentissage
+    iterations = 1000
+
+    # Exécuter la descente de gradient
+    theta_0_opt, theta_1_opt, cost_history = gradient_descent(X, y, theta_0_init, theta_1_init, learning_rate, iterations)
+
+    # Sauvegarder les paramètres optimisés
+    np.save("model.npy", [theta_0_opt, theta_1_opt]) # Sauvegarde des paramètres optimisés dans un fichier .npy
+    print("Modèle entraîné et paramètres sauvegardés.")
+    print(f"Paramètre optimisé θ₀ = {theta_0_opt}")
+    print(f"Paramètre optimisé θ₁ = {theta_1_opt}")
+
+    # Affichage du coût
+    plot_cost_history(cost_history) # Affichage de l'historique du coût
+    # Affichage de la régression linéaire
+    plot_regression_line(df, theta_0_opt, theta_1_opt)
+    
+    return theta_0_opt, theta_1_opt
+    
+# Exécution directe si appelé en script
+if __name__ == "__main__":
+    train_model()

src/visualization.py

@@ -0,0 +1,87 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+import numpy as np
+
+# Visualisation des données brutes
+def plot_raw_data(df):
+    """Affiche les histogrammes du kilométrage et du prix avant normalisation."""
+    plt.figure(figsize=(12, 5))    
+    # Histogramme du kilométrage
+    plt.subplot(1, 2, 1) # 1 ligne, 2 colonnes, 1ère figure
+    sns.histplot(df["km"], bins = 20, kde=True, color="blue")
+    plt.xlabel("Kilométrage (km)")
+    plt.ylabel("Nombre de voitures")
+    plt.title("Distribution du kilométrage (Données brutes)")    
+    # Histogramme du prix
+    plt.subplot(1, 2, 2) # 1 ligne, 2 colonnes, 2ème figure
+    sns.histplot(df["price"], bins = 20, kde=True, color="green")
+    plt.xlabel("Prix (€)")
+    plt.ylabel("Nombre de voitures")
+    plt.title("Distribution du prix (Données brutes)")
+    plt.show()
+    
+    # Nuage de points
+    plt.figure(figsize=(8, 6))
+    sns.scatterplot(x="km", y="price", data=df, alpha=0.5, color="red")
+    plt.xlabel("Kilométrage (km)")
+    plt.ylabel("Prix (€)")
+    plt.title("Relation entre Kilométrage et Prix (Données brutes)")
+    plt.show()
+
+# Visualisation des données normalisées
+def plot_normalized_data(df):
+    """"Affiche les distributions des données après normalisation."""
+    plt.figure(figsize=(12, 5))
+    # Histogramme du kilométrage normalisé
+    plt.subplot(1, 2, 1) # 1 ligne, 2 colonnes, 1ère figure
+    sns.histplot(df["km_norm"], bins = 20, kde=True, color="blue")
+    plt.xlabel("Kilométrage normalisé")
+    plt.ylabel("Nombre de voitures")
+    plt.title("Distribution du kilométrage normalisé")
+    # Histogramme du prix normalisé
+    plt.subplot(1, 2, 2) # 1 ligne, 2 colonnes, 2ème figure
+    sns.histplot(df["price_norm"], bins = 20, kde=True, color="green")
+    plt.xlabel("Prix normalisé")
+    plt.ylabel("Nombre de voitures")
+    plt.title("Distribution du prix normalisé")
+    plt.show()
+    
+    # Nuage de points
+    plt.figure(figsize=(8, 6))
+    sns.scatterplot(x="km_norm", y="price_norm", data=df, alpha=0.5, color="red")
+    plt.xlabel("Kilométrage normalisé")
+    plt.ylabel("Prix normalisé")
+    plt.title("Relation entre Kilométrage et Prix normalisés")
+    plt.show()
+
+
+def plot_cost_history(cost_history):
+    """Affiche l'évolution du coût en fonction du nombre d'itérations."""
+    plt.figure(figsize=(8 , 6)) # taille de la figure
+    plt.plot(range(len(cost_history)), cost_history, 'b-', linewidth=2)
+    plt.xlabel("Nombre d'itérations") # Axe des abscisses
+    plt.ylabel("Coût J(θ)") # Axe des ordonnées
+    plt.title("Evolution du coût en fonction des itérations")
+    plt.grid(True) # Affichage de la grille
+    plt.show()
+    
+# Visualisation de la régression linéaire
+def plot_regression_line(df, theta_0, theta_1):
+    """Affiche la droite de régression linéaire sur les données normalisées."""
+    # Affichage des données normalisées
+    plt.figure(figsize=(8, 6))
+    # Nuage de points des données
+    sns.scatterplot(x=df["km_norm"], y=df["price_norm"], alpha=0.5, label="Données") # alpha=0.5 pour la transparence
+    # Droite de régression linéaire
+    X_range = np.linspace(0, 1, 100) # Génère 100 valeurs entre 0 et 1
+    y_pred = theta_0 + theta_1 * X_range
+    plt.plot(X_range, y_pred, color="red", label="Régression linéaire")
+    plt.xlabel("Kilométrage normalisé")
+    plt.ylabel("Prix normalisé")
+    plt.title("Régression linéaire après entraînement")
+    plt.legend() # Affiche la légende
+    plt.show()
+
+    
+