Trouver le minimum d'une fonction à 3 variables

Version imprimable

28/11/2008, 15h17
QuintusII

Trouver le minimum d'une fonction à 3 variables

Bonjour à tous,

Dans le cadre d'un projet de méthode numérique, nous devons trouver le minimum d'une fonction à 3 variables. Seulement, nous ne pouvons évaluer la fonction que 100 fois!
Auriez-vous une idée?

Merci d'avance
28/11/2008, 18h01
mr_samurai

Salut,

La fonction on question présente des propriétés intéressantes ? continuité, dérivabilité, ou mieux convexité ?

Avec 100 évaluation, c'est très délicat. Tu peux nous expliquer un peu plus ton probléme.

++
01/12/2008, 12h58
QuintusII

On a aucune information sur la fonction :s. En fait, on a une fonction de test mais elle est différente de la fonction avec laquelle on va être tester.

D'après le prof c'est pratiquement impossible de tomber sur la bonne réponse. Il faut juste approcher le plus possible la solution. Voila notre fonction

test: u = sin(3*y-x.^2+1)+7 *cos(2*y.^2-2*x)+ 4 *sin(3*y-z.^2+1) + 2* cos(2*y.^2-2*z).
01/12/2008, 13h08
Jerome Briot

Montre nous ce que tu as déjà essayé de programmer
01/12/2008, 14h28
FR119492

Salut!
Tout d'abord, ta question ne concerne pas spécifiquement Matlab: c'est une question d'algorithmique numérique. Dans cette perspective, à ta place, je regarderais du côté de la méthode des gradients conjugués ou celle du recuit simulé. Essaie les deux avec ta fonction test et choisis la plus efficace.
Jean-Marc Blanc
03/12/2008, 15h24
gagalago

Bonjour, je suis dans la même classe que QuintusII et je me demandais si la fonction fminsearch ne pouvais pas être ce que nous cherchions.
Le seul hic c'est qu'on arrive pas à la faire fonctionner sur une fonction à plus d'une variable. est-ce nous qui nous y prenons mal et alors comment faire? ou est-ce cette fonction qui ne permet pas de trouver un minimum pour des fonctions à plus d'une variable.
Si vous arrivez a faire fonctionner cette fonction, sur une fonction à trois variables, pouvez vous nous poster un exemple qu'on puisse s'en inspirer.

merci d'avance.
03/12/2008, 15h52
mr_samurai
Salut,

FMINSEARCH opère sur les fonctions à plusieurs variable. Pour cela, il faut placer les variables dans un vecteur :
Code:

1 2 3 4 5 % Fonction a minimiser : MyFun(x,y,z) = sin(x) + z^2 + cos(y) MyFun = @(x) sin(x(1)) + x(3).^2 + cos(x(2)); x0 = [1 1 1]; x = fminsearch(MyFun,x0)
++ bonne chance
07/12/2008, 18h49
alias_sg1

Ben le truc c'est qu'on ne connait pas la fonction on connait juste le domaine qui ets un cube de 4 de coté centré à l'origine.

J'avais pensé tester si la fonction est pair par rapport a chacun des 3 axes pour réduire le domaine de recherche mais bon trouver que deux images opposées sont égales ne le prouve pas...
08/12/2008, 09h41
mr_samurai

quelle information tu as sur cette fonction ?
08/12/2008, 13h09
gagalago

rien a part qu'elle est continue.

comment faire pour vectoriser notre fonction quand elle est prise en parametre et nous est donnée sous la forme "u = difficult(x,y,z)"?
08/12/2008, 13h15
mr_samurai

je repose la question différemment,
comment tu défini ta fonction ?
A partir d'un triplet (x,y,z) comment tu obtiens f(x,y,z) ?

On dois pouvoir évaluer une fonction pour la minimiser ;) .

voila le code qu'on njous fournit comme base mais libre a nous de le modiffier comme on veut. les fonction easy et difficult ne sont que des exemples et nous ne seront pas testé sur celles là.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
function matlab7()
global count countmax
 
close all;
 
functions = {@easy,@difficult}; 
for i=1:length(functions) 
 
    u = functions{i}; 
    count = 0; countmax = 100000;
    xi = -2:.1:2;
    [X Y Z] = meshgrid(xi,xi,xi); 
    U = u(X,Y,Z);
    figure; slice(X,Y,Z,U,[-1.2,.8,2],[2],[-2])
    fprintf('\n Count %d : Global minimum = %14.7e',count,min(min(min(U))));
 
end
end
 
function u = easy(x,y,z)
global count countmax;
count = count+ prod(size(x));
if (count > countmax) 
    error('Too much evaluations : my poor guy !'); 
end
u = (x-0.1).^2 + (y - 0.4).^2 + (z - 0.3).^2;
end
 
function u = difficult(x,y,z)
global count countmax;
count = count+ prod(size(x));
if (count > countmax) 
    error('Too much evaluations : my poor guy !'); 
end
u = sin(3*y-x.^2+1)+7 *cos(2*y.^2-2*x)+ 4 *sin(3*y-z.^2+1) + 2* cos(2*y.^2-2*z);
end

08/12/2008, 13h43
FR119492

Salut!

Citation:

Dans cette perspective, à ta place, je regarderais du côté de la méthode des gradients conjugués ou celle du recuit simulé. Essaie les deux avec ta fonction test et choisis la plus efficace.

Est-ce qu'il t'arrive de lire les suggestions des développeurs plus expérimentés?

Citation:

u = sin(3*y-x.^2+1)+7 *cos(2*y.^2-2*x)+ 4 *sin(3*y-z.^2+1) + 2* cos(2*y.^2-2*z)

mr_samurai a effectivement mis le doigt sur le point important: comment la fonction est-elle donnée? La fonction test semble l'être sous forme analytique. Celle que tu devras étudier le sera-t-elle aussi?

Jean-Marc Blanc

J'ai fait des modification sur ton Code (ajouter le code de calcul avec FMINSEARCH) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
 
function matlab7()
global count countmax
 
clc
close all;
 
%----- Version adapté a 'fminsearch'
easy2 = @(x) (x(1)-0.1).^2 + (x(2) - 0.4).^2 + (x(3) - 0.3).^2;
difficult2= @(x) sin(3*x(2) - x(1).^2+1)+7 *cos(2*x(2).^2-2*x(1))+ ...
    4 *sin(3*x(2)-x(3).^2+1) + 2* cos(2*x(2).^2-2*x(3));
%----- 
 
 
functions = {@easy,@difficult}; 
functions2 = {easy2,difficult2}; 
 
for i=1:length(functions) 
 
    u = functions{i}; 
    u2 = functions2{i}; 
 
    %----- Minimiser Sur un pavé
    tic
    count = 0; countmax = 100000;
    xi = -2:.1:2;
    [X Y Z] = meshgrid(xi,xi,xi); 
    U = u(X,Y,Z);
    figure; slice(X,Y,Z,U,[-1.2,.8,2],[2],[-2])
    fprintf('\n Count %d : Global minimum = %14.7e \n',count,min(min(min(U))));
    toc
 
    %----- Minimum avec 'fminsearch'
    tic
    x0 = [0 0 0];
    fprintf('\n fminsearch minimum = %14.7e \n', u2(fminsearch(u2,x0)))
    toc
end
 
function u = easy(x,y,z)
global count countmax;
count = count+ prod(size(x));
if (count > countmax) 
    error('Too much evaluations : my poor guy !'); 
end
u = (x-0.1).^2 + (y - 0.4).^2 + (z - 0.3).^2;
end
 
function u = difficult(x,y,z)
global count countmax;
count = count+ prod(size(x));
if (count > countmax) 
    error('Too much evaluations : my poor guy !'); 
end
u = sin(3*y-x.^2+1)+7 *cos(2*y.^2-2*x)+ 4 *sin(3*y-z.^2+1) + 2* cos(2*y.^2-2*z);
end
 
end

C'est deux fois plus rapide.
++