Discussion :

[QuintusII]

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

[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.

++

[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).

[Jerome Briot]

Montre nous ce que tu as déjà essayé de programmer

[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

[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.

[mr_samurai]

Salut,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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...

[mr_samurai]

quelle information tu as sur cette fonction ?

[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)"?

[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 .

[gagalago]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[FR119492]

Salut!

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?

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

[mr_samurai]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.
++