Regression linéaire avec scikit-learn  

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression
from sklearn.linear_model import LinearRegression

# Génération du Dataset
m = 50
x, y = make_regression(n_samples=m, n_features=1, noise=15)
y = y.reshape(m, 1)

# Ajout d'une ordonnée à l'origine non nulle
rd = np.random.randint(-50, 50)
y = y - rd

# Visualisation du nuage de points
plt.scatter(x, y, label="Nuage de points", color="blue", alpha=0.6)
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Nuage de points")
plt.legend()
plt.grid(True)
plt.show()

# Régression linéaire avec scikit-learn
model = LinearRegression()
model.fit(x, y)  # Entraînement du modèle

# Extraction des coefficients
a = model.coef_[0][0]  # Coefficient directeur
b = model.intercept_[0]  # Ordonnée à l'origine

print(f"Coefficient a (pente) : {a:.2f}")
print(f"Ordonnée à l'origine b : {b:.2f}")

# Prédictions
y_pred = model.predict(x)

# Visualisation du modèle
plt.scatter(x, y, label="Nuage de points", color="blue", alpha=0.6)
plt.plot(x, y_pred, label=f"Modèle linéaire y = {a:.2f}x + {b:.2f}", color="red", linewidth=2)

# Ajout des barres d'erreurs
for i in range(len(x)):
    plt.plot([x[i][0], x[i][0]], [y[i][0], y_pred[i][0]], color="gray", linestyle="--", linewidth=0.8)

plt.xlabel("X")
plt.ylabel("Y")
plt.title("Régression linéaire avec scikit-learn")
plt.legend()
plt.grid(True)
plt.show()

# Calcul du coût (MSE : Mean Squared Error)
J = (1 / (2 * m)) * np.sum((y_pred - y) ** 2)
print(f"Coût J (MSE) : {J:.2f}")

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_regression

# Génération du Dataset
m = 50
x, y = make_regression(n_samples=m, n_features=1, noise=10)
y = y.reshape(m, 1)

# Ajout d'une ordonnée à l'origine non nulle
rd = np.random.randint(-50, 50)
y = y - rd
y = y + abs(y/2) # dataset non-linéaire

# Visualisation des données
plt.scatter(x, y, label="Nuage de points", color="blue", alpha=0.6)
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Nuage de points")
plt.legend()
plt.grid(True)
plt.show()

from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error


# Transformation en données polynomiales
degree = 2  # On veut ajuster un modèle polynomial de degré 2
poly_features = PolynomialFeatures(degree=degree, include_bias=False)
x_poly = poly_features.fit_transform(x)  # Transformation des données

# Régression linéaire sur les données transformées
model = LinearRegression()
model.fit(x_poly, y)  # Entraînement du modèle

# Extraction des coefficients
a = model.coef_[0][0]  # Coefficient de x^2
b = model.coef_[0][1]  # Coefficient de x
c = model.intercept_[0]  # Ordonnée à l'origine

print(f"Coefficient a (x^2) : {a:.2f}")
print(f"Coefficient b (x) : {b:.2f}")
print(f"Ordonnée à l'origine c : {c:.2f}")

# Prédictions
y_pred = model.predict(x_poly)

# Visualisation du modèle polynomial
plt.scatter(x, y, label="Nuage de points", color="blue", alpha=0.6)
sorted_idx = np.argsort(x[:, 0])
plt.plot(x[sorted_idx], y_pred[sorted_idx], label=f"Modèle polynomial y = {a:.2f}x^2 + {b:.2f}x + {c:.2f}", color="red", linewidth=2)

# Ajout des barres d'erreurs
for i in range(len(x)):
    plt.plot([x[i][0], x[i][0]], [y[i][0], y_pred[i][0]], color="gray", linestyle="--", linewidth=0.8)

plt.xlabel("X")
plt.ylabel("Y")
plt.title("Régression polynomial avec scikit-learn")
plt.legend()
plt.grid(True)
plt.show()

# Calcul du coût (MSE : Mean Squared Error)
J = mean_squared_error(y, y_pred) / 2  # On divise par 2 pour obtenir J(a, b, c)
print(f"Coût J (MSE / 2) : {J:.2f}")

from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler

# Normalisation des données
scaler_x = StandardScaler()
scaler_y = StandardScaler()

x_scaled = scaler_x.fit_transform(x)
y_scaled = scaler_y.fit_transform(y)

# Création du modèle SVR avec noyau RBF
svr_model = SVR(kernel='rbf', C=10, epsilon=0.3, gamma="scale")
svr_model.fit(x_scaled, y_scaled.ravel())

# Prédictions
y_pred_scaled = svr_model.predict(x_scaled)
y_pred = scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1))

# Visualisation des résultats
plt.scatter(x, y, label="Nuage de points", color="blue", alpha=0.6)
sorted_idx = np.argsort(x[:, 0])  # Tracé des points triés
plt.plot(x[sorted_idx], y_pred[sorted_idx], label="Modèle SVR (noyau RBF)", color="red", linewidth=2)

# Ajout des barres d'erreurs
for i in range(len(x)):
    plt.plot([x[i][0], x[i][0]], [y[i][0], y_pred[i][0]], color="gray", linestyle="--", linewidth=0.8)

plt.xlabel("X")
plt.ylabel("Y")
plt.title("Régression SVR avec noyau RBF")
plt.legend()
plt.grid(True)
plt.show()

# Calcul du coût (MSE)
J = (1 / (2 * m)) * np.sum((y_pred.ravel() - y.ravel()) ** 2)
print(f"Coût J (MSE / 2) : {J:.2f}")

from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV

# Normalisation des données
scaler_x = StandardScaler()
scaler_y = StandardScaler()

x_scaled = scaler_x.fit_transform(x)
y_scaled = scaler_y.fit_transform(y)

# Recherche des meilleurs hyperparamètres pour SVR
param_grid = {
    "kernel": ["linear", "poly", "rbf"],  # Test des noyaux
    "C": [0.1, 1, 10, 100],              # Régularisation
    "epsilon": [0.01, 0.1, 1],           # Zone d'insensibilité
    "degree": [2, 3, 4]                  # Pour le noyau polynomial
}
svr = SVR()
grid_search = GridSearchCV(svr, param_grid, cv=3, scoring="neg_mean_squared_error")
grid_search.fit(x_scaled, y_scaled.ravel())

# Meilleur modèle trouvé
best_model = grid_search.best_estimator_
print("Meilleurs hyperparamètres :", grid_search.best_params_)

# Prédictions
y_pred_scaled = best_model.predict(x_scaled)
y_pred = scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1))

# Visualisation des résultats
plt.scatter(x, y, label="Nuage de points", color="blue", alpha=0.6)
sorted_idx = np.argsort(x[:, 0])
plt.plot(x[sorted_idx], y_pred[sorted_idx], label="Modèle SVR optimal", color="red", linewidth=2)

# Ajout des barres d'erreurs
for i in range(len(x)):
    plt.plot([x[i][0], x[i][0]], [y[i][0], y_pred[i][0]], color="gray", linestyle="--", linewidth=0.8)

plt.xlabel("X")
plt.ylabel("Y")
plt.title("Régression SVR avec recherche d'hyperparamètres")
plt.legend()
plt.grid(True)
plt.show()

# Calcul du coût (MSE)
J = (1 / (2 * m)) * np.sum((y_pred.ravel() - y.ravel()) ** 2)
print(f"Coût J (MSE / 2) : {J:.2f}")