République Algérienne démocratique et populaire
Ministère de l’enseignement supérieur et de la recherche scientifique
Université M’hamed BOUGARA Boumerdes
Faculté de Technologie
Département génie mécanique
Compte rendu du TP Optimisation
Réalisé par :
M’zala Aya
Ansar Aya karima
Année universitaire : 2024/2025
1. Introduction et but de TP :
Ce travail pratique (TP) porte sur l'optimisation non linéaire et explore diverses techniques et
méthodes pour résoudre des problèmes complexes. À travers une série d'exercices, nous avons
utilisé MATLAB pour visualiser des fonctions, analyser leur convexité, et appliquer des
méthodes de gradient et de Newton pour identifier les minima locaux. Les exercices abordent
également la minimisation de volumes et l'utilisation de méthodes de calcul avancées, telles
que les algorithmes génétiques et la méthode Fmincon, pour trouver des solutions optimisées.
L'objectif de ce TP est de renforcer notre compréhension des concepts théoriques et de
développer nos compétences pratiques en optimisation.
2. Optimisation linéaire :
2.1. Résoudre le problème en utilisant la méthode de graphe :
Min z = 2x1 + 4x2
x1 ≥ 6 x1=6
x1 ≤ 10 x1=10
x2 ≤ 4 x2=4
x2 ≥ 1 x2=1
2x1 - 2x2 ≥ 4
2x1 - 2x2 = 4 : A(0 ; 2) ; B(6 ;4)
4,5x1 + 6x2 ≥ 16
4,5x1 + 6x2 = 16 : C(1 ; 2,22) ; D(2,6 ; 0)
x1 ,x2 ≥ 0
2.2. A l’aide de simplexe résoudre le problème :
Programme sur Matlab :
% Coefficients de la fonction objectif (à maximiser)
c = [-7, -9, -18, -17, -5, -10, -20, -15, -11, -8];
% Coefficients des contraintes
A = [2, 4, 5, 7, 5, 10, 3, 8, 9, 5;
1, 1, 2, 2, 3, 4, 5, 2, 1, 0;
1, 2, 3, 3, 2, 5, 7, 0, 1, 1;
2, 4, 5, 7, 4, 5, 0, 8, 1, 0;];
% Limites des ressources
b = [41, 14, 21, 54];
% Options pour l'algorithme du simplexe
options = optimoptions('linprog', 'Algorithm', 'dual-simplex', 'Display', 'iter');
% Résolution du problème
[x, fval] = linprog(c, A, b, [ ], [ ], zeros(size(c)), [ ], options);
% Affichage des résultats
disp('Quantités produites des produits :');
disp(x);
disp('Bénéfice total :');
disp(-fval);
Résultats :
2.3. A l’aide de simplexe resoudre le probleme :
Programme :
% Définir les coefficients de la fonction objective
f = -[3 5 -2 4 6 -1 2 -3 7 2];
% Définir les coefficients des contraintes
A = [2 -3 1 4 2 1 -1 5 -2 3;
1 -1 2 1 -1 4 2 1 -3 5;
4 2 1 -3 5 1 2 -1 3 4;
3 2 5 -1 -1 2 4 -2 6 1;
2 3 -1 4 1 -2 3 5 -2 1;
1 2 3 -1 4 2 -1 3 6 1;
1 -1 2 3 1 4 2 -1 -3 5;
3 2 1 3 5 1 2 -1 3 4];
b = [15; 20; 25; 10; 8; 30; 12; 18];
% Définir les bornes inférieures et supérieures
lb = zeros(10, 1); % Les variables doivent être non négatives
ub = [ ]; % Pas de bornes supérieures
% Résoudre le problème de programmation linéaire
[x, fval, exitflag, output] = linprog(f, A, b, [ ], [ ], lb, ub);
% Afficher les résultats
disp('Solution:')
disp(x)
disp('Valeur de la fonction objective:')
disp(-fval)
Résultats :
3. Optimisation non lineaire :
3.1. A l’aide de programme Matlab :
Dessin de la fonction :
Programme :
% Définir les intervalles
x = -5:0.2:5;
y = -5:0.2:5;
[X, Y] = meshgrid(x, y);
% Définir la fonction
f = (X + 1).^4 - cos(Y + 1);
% Tracer la fonction
figure;
surf(X, Y, f);
title('f(x, y) = (x + 1)^4 - cos(y + 1)');
xlabel('x');
ylabel('y');
zlabel('f(x, y)');
Résultat :
Convexité :
Programme :
syms x y;
% Définir la fonction
f = (x + 1)^4 - cos(y + 1);
% Calculer les dérivées partielles secondes
f_xx = diff(f, x, 2);
f_yy = diff(f, y, 2);
f_xy = diff(diff(f, x), y);
% Afficher les dérivées partielles secondes
disp('Dérivée seconde par rapport à x (f_xx):');
disp(f_xx);
disp('Dérivée seconde par rapport à y (f_yy):');
disp(f_yy);
disp('Dérivée croisée (f_xy):');
disp(f_xy);
% Calculer la matrice Hessienne
H = [f_xx, f_xy; f_xy, f_yy];
disp('Matrice Hessienne:');
disp(H);
% Calculer les valeurs propres de la matrice Hessienne
eig_H = eig(H);
disp('Valeurs propres de la matrice Hessienne:');
disp(eig_H);
Résultats :
Analyse de la convexité :
12(x+1)2 est toujours positive ou nulle.
Cos (y+1) oscille netre -1 et 1 , pouvant etre positive ou négative.
Donc , la fonction n’est pas globalement convexe
-Dans le même graphe, pour les deux méthodes, tracer l’évolution de x en
fonction d’itération.
-Dans le même graphe, pour les deux méthodes, tracer l’évolution de l’erreur en
fonction d’itération.
Programme :
% Initialisation des points de départ et des paramètres
x0 = [1; 1];
tol = 1e-4;
max_iter = 100;
% Définition de la fonction et de ses dérivées
f = @(x) (x(1) + x(2))^2 + 1;
grad_f = @(x) [2 * (x(1) + x(2)); 2 * (x(1) + x(2))];
hess_f = @(x) [2, 2; 2, 2];
% Méthode du gradient
x_grad = x0;
x_grad_history = x0';
error_grad_history = [];
for iter = 1:max_iter
grad = grad_f(x_grad);
x_grad = x_grad - 0.01 * grad;
x_grad_history = [x_grad_history; x_grad'];
error_grad_history = [error_grad_history; norm(grad)];
if norm(grad) < tol
break;
end
end
% Méthode de Newton avec régularisation
lambda = 1e-4;
x_newton = x0;
x_newton_history = x0';
error_newton_history = [];
for iter = 1:max_iter
grad = grad_f(x_newton);
hess = hess_f(x_newton) + lambda * eye(size(hess_f(x_newton)));
x_newton = x_newton - hess \ grad;
x_newton_history = [x_newton_history; x_newton'];
error_newton_history = [error_newton_history; norm(grad)];
if norm(grad) < tol
break;
end
end
% Tracer l'évolution de x
figure;
plot(x_grad_history(:, 1), '-o', 'DisplayName', 'Méthode du gradient');
hold on;
plot(x_newton_history(:, 1), '-x', 'DisplayName', 'Méthode de Newton');
title('Évolution de x en fonction de l''itération');
xlabel('Itération');
ylabel('x');
legend;
% Tracer l'évolution de l'erreur
figure;
plot(error_grad_history, '-o', 'DisplayName', 'Méthode du gradient');
hold on;
plot(error_newton_history, '-x', 'DisplayName', 'Méthode de Newton');
title('Évolution de l''erreur en fonction de l''itération');
xlabel('Itération');
ylabel('Erreur');
legend;
conclusion :
1. Évolution de \( x \) :
- Méthode du gradient : Convergence progressive et lente.
- Méthode de Newton : Convergence rapide.
2. Évolution de l'erreur :
- Méthode du gradient : Diminution régulière mais lente.
- Méthode de Newton : Diminution rapide, atteignant presque zéro rapidement.
En résumé :
- Méthode de Newton : Plus rapide et efficace, mais nécessite une matrice Hessienne bien
conditionnée.
- Méthode du gradient : Plus robuste et simple, mais plus lente.
3.2. Présenter graphiquement la fonction de test de Rosenbrock et la
fonction Rastrigin. Trouver ses points min à l’aide de la méthode
GA et Fminsearch en remplissant le tableau ci- dessus
% Configuration pour l'utilisation de la méthode GA
options = optimoptions('ga', 'Display', 'iter', 'PlotFcn', @gaplotbestf);
% Fonction de test de Rosenbrock
rosenbrock = @(x) 100*(x(2) - x(1)^2)^2 + (1 - x(1))^2;
% Utilisation de la méthode GA pour Rosenbrock
[x_rosen_GA, fval_rosen_GA] = ga(rosenbrock, 2, [], [], [], [], [-20, -20], [20,
20], [], options);
% Fonction de test Rastrigin
rastrigin = @(x) 10*length(x) + sum(x.^2 - 10*cos(2*pi*x));
% Utilisation de la méthode GA pour Rastrigin
[x_rastrigin_GA, fval_rastrigin_GA] = ga(rastrigin, 2, [], [], [], [], [-20, -20],
[20, 20], [], options);
Tableau 1 Fonction Rosenbrock (- Fonction Rastrigin ( -20<=xi<=20)
20<=xi<=20)
Méthode Solution x F(x) Solution x F(x)
GA [1 , 1] 0 [0,0] 0
Fminsearch [0,990,0,981] 1,0094 e-04 [0,0] 0
3.3. Design d’un ressort
% Fonction objective
function V = objective(x)
N = x(1);
D = x(2);
d = x(3);
V = (N + 2) * D * d^2;
end
% Contraintes
function [c, ceq] = constraints(x)
N = x(1);
D = x(2);
d = x(3);
g1 = 1 - (D^3 * d) / (71785 * N^4);
g2 = (4 * D^2 - D * d) / (12566 * (D * d^3 - d^4)) + 1 / (5108 * d^2) - 1;
g3 = 1 - (140.45 * D) / (d^2 * N);
g4 = (D + d) / 1.5 - 1;
c = [g1; g2; g3; g4];
ceq = [];
end
% Paramètres initiaux
x0 = [4, 0.6, 0.3];
% Bornes des variables
lb = [2, 0.25, 0.05];
ub = [8, 1.2, 3];
% Options de l'optimisation
options = optimoptions('fmincon', 'Algorithm', 'sqp', 'Display', 'iter');
% Appel de la fonction d'optimisation
[x, fval] = fmincon(@objective, x0, [], [], [], [], lb, ub, @constraints, options);
% Affichage des résultats
disp('Résultats optimaux:');
disp(['N (nombre de spires actives) = ', num2str(x(1))]);
disp(['D (diamètre de la spire) = ', num2str(x(2))]);
disp(['d (diamètre du fil) = ', num2str(x(3))]);
disp(['Volume minimisé du ressort = ', num2str(fval)]);
résultat :
3.4. Rendement hydraulique local d’un profil d’aube
Programme :
% Fonction pour calculer le rendement hydraulique
function eta_H = rendement_hydraulique(beta_m, alpha_m, epsilon1, epsilon2)
eta_H = (tan(beta_m - epsilon1) + tan(alpha_m - epsilon2)) / (tan(beta_m) + tan(alpha_m));
end
% Paramètres
epsilon1 = 1;
epsilon2 = 1.5;
beta_m_range = [16.45, 70]; % en degrés
alpha_m_range = [16.12, 53.91]; % en degrés
% Convertir les degrés en radians pour les calculs trigonométriques
beta_m_range = deg2rad(beta_m_range);
alpha_m_range = deg2rad(alpha_m_range);
% Calculer le rendement hydraulique pour les bornes
eta_H_min = rendement_hydraulique(beta_m_range(1), alpha_m_range(1), epsilon1, epsilon2);
eta_H_max = rendement_hydraulique(beta_m_range(2), alpha_m_range(2), epsilon1, epsilon2);
% Affichage des résultats
fprintf('Rendement hydraulique minimum : %.4f\n', eta_H_min);
fprintf('Rendement hydraulique maximum : %.4f\n', eta_H_max);
Résultat :
conclusion :
En conclusion, ce TP nous a permis d'approfondir notre compréhension de l'optimisation non
linéaire à travers une série d'exercices pratiques variés. L'utilisation de MATLAB et de différentes
méthodes d'optimisation nous a permis de visualiser et de résoudre des problèmes complexes de
manière efficace. Chaque méthode utilisée, des algorithmes de gradient aux algorithmes
métaheuristiques, a présenté des avantages spécifiques et a contribué à notre apprentissage global.
Ce TP a été un excellent moyen de mettre en pratique nos connaissances théoriques et de
développer nos compétences en résolution de problèmes, nous préparant ainsi à des défis futurs
dans le domaine de l'optimisation.
