Voici un exemple de code complet pour utiliser PSO afin d’optimiser une
régression linéaire sous MATLAB. Je vais inclure les explications détaillées
à chaque étape du processus. Vous pourrez adapter le code en fonction de
vos besoins spécifiques.
1. Initialisation des données
Vous devez commencer par charger vos données et définir la fonction de
régression linéaire. Pour cet exemple, supposons que vous avez des
données d’entrée X et des valeurs cibles Y.
2. Fonction de régression linéaire
La régression linéaire peut être modélisée par l’équation :
Y_{\text{préd}} = w_1 \cdot X + w_2
Ici, w_1 est le coefficient de pente, et w_2 est l’ordonnée à l’origine. Ce
sont les paramètres que nous voulons optimiser.
3. Code MATLAB avec PSO
Voici un code complet pour optimiser les paramètres w_1 et w_2 d’une
régression linéaire via PSO :
% Initialisation des données
% Remplacer par vos données réelles
X = [1, 2, 3, 4, 5] ; % Exemple de données d’entrée
Y = [2.1, 4.1, 6.1, 8.1, 10.1] ; % Exemple de données réelles (quantité
d’or obtenue)
% Fonction de régression linéaire
% Y_pred = w1 * X + w2
Function Y_pred = linear_regression(params, X)
W1 = params(1) ; % Coefficient de pente
W2 = params(2) ; % Ordonnée à l’origine
Y_pred = w1 * X + w2 ;
End
% Fonction objectif à minimiser
% Cette fonction calcule l’erreur quadratique moyenne (MSE)
Function error = objective_function(params)
Global X Y
Y_pred = linear_regression(params, X) ; % Prédiction à l’aide du modèle
linéaire
Error = mean((Y – Y_pred).^2) ; % Calcul de l’erreur MSE
End
% Initialisation du PSO
Function [best_params, best_error] = pso_optimization()
Global X Y
% Paramètres PSO
N_particles = 30 ; % Nombre de particules
N_iterations = 100 ; % Nombre d’itérations
Param_min = [-10, -10] ; % Limites inférieures des paramètres [w1, w2]
Param_max = [10, 10] ; % Limites supérieures des paramètres [w1,
w2]
% PSO settings
Inertia_weight = 0.7 ; % Poids d’inertie (influence de la vitesse
précédente)
Cognitive_param = 1.5 ; % Facteur cognitif (influence de la meilleure
position personnelle)
Social_param = 1.5 ; % Facteur social (influence de la meilleure
position globale)
% Initialisation des particules
Swarm = struct() ;
For i = 1 :n_particles
Swarm(i).position = param_min + (param_max – param_min) .*
rand(1, 2) ; % Positions aléatoires initiales
Swarm(i).velocity = zeros(1, 2) ; % Vitesse initiale (0)
Swarm(i).best_position = swarm(i).position ; % Meilleure position
personnelle (initiale)
Swarm(i).best_error = objective_function(swarm(i).position) ; %
Erreur initiale
End
% Meilleure position globale initiale
[~, best_idx] = min([swarm.best_error]) ;
Global_best_position = swarm(best_idx).best_position ;
Global_best_error = swarm(best_idx).best_error ;
% Boucle PSO
For iter = 1 :n_iterations
For i = 1 :n_particles
% Mise à jour de la vitesse
Swarm(i).velocity = inertia_weight * swarm(i).velocity …
+ cognitive_param * rand(1, 2) .* (swarm(i).best_position –
swarm(i).position) …
+ social_param * rand(1, 2) .* (global_best_position –
swarm(i).position) ;
% Mise à jour de la position
Swarm(i).position = swarm(i).position + swarm(i).velocity ;
% Limitation des positions dans les bornes [param_min,
param_max]
Swarm(i).position = max(param_min, min(param_max,
swarm(i).position)) ;
% Calcul de l’erreur actuelle
Current_error = objective_function(swarm(i).position) ;
% Mise à jour de la meilleure position personnelle
If current_error < swarm(i).best_error
Swarm(i).best_position = swarm(i).position ;
Swarm(i).best_error = current_error ;
End
% Mise à jour de la meilleure position globale
If current_error < global_best_error
Global_best_position = swarm(i).position ;
Global_best_error = current_error ;
End
End
% Affichage de la progression
Fprintf(‘Iteration %d, Best Error : %f\n’, iter, global_best_error) ;
End
% Résultats finaux
Best_params = global_best_position ;
Best_error = global_best_error ;
End
% Exécution de l’optimisation par PSO
[best_params, best_error] = pso_optimization() ;
% Affichage des meilleurs paramètres trouvés
Fprintf(‘Meilleur w1 : %f\n’, best_params(1)) ;
Fprintf(‘Meilleur w2 : %f\n’, best_params(2)) ;
Fprintf(‘Erreur minimale obtenue : %f\n’, best_error) ;
4. Explications du code
Données (X et Y) : Remplacez X par vos données d’entrée et Y par vos
données réelles (quantité d’or obtenue).
Fonction de régression linéaire : La fonction linear_regression prend les
paramètres w1 et w2 (les coefficients de la régression) et calcule les
prédictions pour les données d’entrée.
Fonction objectif (objective_function) : Cette fonction mesure l’erreur
quadratique moyenne (MSE) entre les valeurs prédites et les valeurs
réelles. PSO cherchera à minimiser cette erreur.
Initialisation du PSO : Le PSO est configuré avec 30 particules et 100
itérations. Les paramètres à optimiser (w1 et w2) sont initialisés
aléatoirement dans les limites définies (param_min et param_max).
Boucle PSO : Pour chaque particule, la vitesse et la position sont mises à
jour en fonction de l’inertie, du facteur cognitif (meilleure position
personnelle) et du facteur social (meilleure position globale). À chaque
itération, PSO cherche à améliorer la position des particules pour
minimiser l’erreur.
5. Remplacer les éléments spécifiques
Remplacez X et Y par vos vraies données.
Ajustez param_min et param_max selon les plages de valeurs des
paramètres que vous souhaitez explorer.
Résultats
Une fois le PSO terminé, les meilleurs paramètres de régression (w1 et w2)
seront affichés ainsi que l’erreur minimale obtenue.
Si vous avez besoin de clarifications supplémentaires ou d’ajustements,
n’hésitez pas à demander !