Cette page a été traduite par traduction automatique. Cliquez ici pour voir la dernière version en anglais.

patternsearch

Trouver le minimum de fonction en utilisant la recherche de modèle

réduire tous les éléments de la page

Syntaxe

x = patternsearch(fun,x0)

x = patternsearch(fun,x0,A,b)

x = patternsearch(fun,x0,A,b,Aeq,beq)

x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub)

x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon)

x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options)

x = patternsearch(problem)

[x,fval] = patternsearch(___)

[x,fval,exitflag,output] = patternsearch(___)

Description

x = patternsearch(fun,x0) trouve un minimum local, x, pour le handle de fonction fun qui calcule les valeurs de la fonction objectif. x0 est un vecteur réel spécifiant un point initial pour l'algorithme de recherche de motif.

Remarque

Passing Extra Parameters explique comment passer des paramètres supplémentaires à la fonction objectif et aux fonctions de contrainte non linéaire, si nécessaire.

exemple

x = patternsearch(fun,x0,A,b) minimise fun sous réserve des inégalités linéaires A*x ≤ b. Voir Linear Inequality Constraints.

exemple

x = patternsearch(fun,x0,A,b,Aeq,beq) minimise fun sous réserve des égalités linéaires Aeq*x = beq et A*x ≤ b. Si aucune inégalité linéaire n'existe, définissez A = [] et b = [].

x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub) définit un ensemble de limites inférieures et supérieures sur les variables de conception dans x, de sorte que la solution soit toujours dans la plage lb ≤ x ≤ ub. Si aucune égalité linéaire n'existe, définissez Aeq = [] et beq = []. Si x(i) n'a pas de limite inférieure, définissez lb(i) = -Inf. Si x(i) n'a pas de limite supérieure, définissez ub(i) = Inf.

exemple

x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon) soumet la minimisation aux inégalités non linéaires c(x) ou aux égalités ceq(x) définies dans nonlcon. patternsearch optimise fun de telle sorte que c(x) ≤ 0 et ceq(x) = 0. S'il n'existe aucune limite, définissez lb = [], ub = [] ou les deux.

exemple

x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options) minimise fun avec les options d'optimisation spécifiées dans options. Utilisez optimoptions pour définir ces options. S'il n'y a pas d'inégalité non linéaire ou de contraintes d'égalité, définissez nonlcon = [].

exemple

x = patternsearch(problem) trouve le minimum pour problem, une structure décrite dans problem.

[x,fval] = patternsearch(___), quelle que soit la syntaxe, renvoie la valeur de la fonction objectif fun à la solution x.

exemple

[x,fval,exitflag,output] = patternsearch(___) renvoie également exitflag, une valeur qui décrit la condition de sortie de patternsearch, et une structure output avec des informations sur le processus d'optimisation.

exemple

Exemples

réduire tout

Minimisation de la recherche de modèles sans contrainte

Ouvrir le script

Minimisez un problème sans contrainte en utilisant le solveur patternsearch.

Créez la fonction objectif à deux variables suivante. Sur votre chemin MATLAB ®, enregistrez le code suivant dans un fichier nommé psobj.m.

function y = psobj(x)

y = exp(-x(1)^2-x(2)^2)*(1+5*x(1) + 6*x(2) + 12*x(1)*cos(x(2)));

Définissez la fonction objectif sur @psobj.

fun = @psobj;

Trouvez le minimum, en commençant au point [0,0].

x0 = [0,0];
x = patternsearch(fun,x0)

patternsearch stopped because the mesh size was less than options.MeshTolerance.

x =

   -0.7037   -0.1860

Recherche de modèle avec une contrainte d'inégalité linéaire

Ouvrir le script

Minimiser une fonction soumise à certaines contraintes d’inégalité linéaire.

Créez la fonction objectif à deux variables suivante. Sur votre chemin MATLAB ®, enregistrez le code suivant dans un fichier nommé psobj.m.

function y = psobj(x)

y = exp(-x(1)^2-x(2)^2)*(1+5*x(1) + 6*x(2) + 12*x(1)*cos(x(2)));

Définissez la fonction objectif sur @psobj.

fun = @psobj;

Définissez les deux contraintes d’inégalité linéaire.

A = [-3,-2;
    -4,-7];
b = [-1;-8];

Trouvez le minimum, en commençant au point [0.5,-0.5].

x0 = [0.5,-0.5];
x = patternsearch(fun,x0,A,b)

patternsearch stopped because the mesh size was less than options.MeshTolerance.

x =

    5.2827   -1.8758

Recherche de patterns avec limites

Ouvrir le script

Trouvez le minimum d'une fonction qui n'a que des contraintes bornées.

Créez la fonction objectif à deux variables suivante. Sur votre chemin MATLAB ®, enregistrez le code suivant dans un fichier nommé psobj.m.

function y = psobj(x)

y = exp(-x(1)^2-x(2)^2)*(1+5*x(1) + 6*x(2) + 12*x(1)*cos(x(2)));

Définissez la fonction objectif sur @psobj.

fun = @psobj;

Trouver le minimum lorsque $0 \le x(1) \le\infty$ et $-\infty \le x(2) \le -3$ .

lb = [0,-Inf];
ub = [Inf,-3];
A = [];
b = [];
Aeq = [];
beq = [];

Trouvez le minimum, en commençant au point [1,-5].

x0 = [1,-5];
x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub)

patternsearch stopped because the mesh size was less than options.MeshTolerance.

x =

    0.1880   -3.0000

Recherche de modèles avec des contraintes non linéaires

Ouvrir le script

Trouver le minimum d'une fonction soumise à une contrainte d'inégalité non linéaire.

Créez la fonction objectif à deux variables suivante. Sur votre chemin MATLAB ®, enregistrez le code suivant dans un fichier nommé psobj.m.

function y = psobj(x)

y = exp(-x(1)^2-x(2)^2)*(1+5*x(1) + 6*x(2) + 12*x(1)*cos(x(2)));

Définissez la fonction objectif sur @psobj.

fun = @psobj;

Créez la contrainte non linéaire

$\frac{{xy}}{2} + {\left( {x + 2} \right)^2} + \frac{{{{\left( {y - 2}
\right)}^2}}}{2} \le 2.$

Pour ce faire, sur votre chemin MATLAB, enregistrez le code suivant dans un fichier nommé ellipsetilt.m.

function [c,ceq] = ellipsetilt(x)
ceq = [];
c = x(1)*x(2)/2 + (x(1)+2)^2 + (x(2)-2)^2/2 - 2;

Démarrez patternsearch à partir du point initial [-2,-2].

x0 = [-2,-2];
A = [];
b = [];
Aeq = [];
beq = [];
lb = [];
ub = [];
nonlcon = @ellipsetilt;
x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon)

Optimization finished: mesh size less than options.MeshTolerance 
and constraint violation is less than options.ConstraintTolerance.

x =

   -1.5144    0.0875

Essayer différents algorithmes `patternsearch`

Ouvrir le live script

Parfois, les différents algorithmes patternsearch ont un comportement sensiblement différent. Bien qu’il puisse être difficile de prédire quel algorithme fonctionne le mieux pour un problème, vous pouvez facilement essayer différents algorithmes. Pour cet exemple, utilisez la fonction objectif sawtoothxy, qui est disponible lorsque vous exécutez cet exemple, et qui est décrite et tracée dans Trouver des minima globaux ou locaux multiples.

type sawtoothxy

function f = sawtoothxy(x,y)
[t r] = cart2pol(x,y); % change to polar coordinates
h = cos(2*t - 1/2)/2 + cos(t) + 2;
g = (sin(r) - sin(2*r)/2 + sin(3*r)/3 - sin(4*r)/4 + 4) ...
    .*r.^2./(r+1);
f = g.*h;
end

Pour voir le comportement des différents algorithmes lors de la minimisation de cette fonction objectif, définissez des limites asymétriques. Définissez également un point initial x0 qui est éloigné de la vraie solution sol = [0 0], où sawtoothxy(0,0) = 0.

rng default
x0 = 12*randn(1,2);
lb = [-15,-26];
ub = [26,15];
fun = @(x)sawtoothxy(x(1),x(2));

Minimisez la fonction sawtoothxy en utilisant l'algorithme "classic" patternsearch.

optsc = optimoptions("patternsearch",Algorithm="classic");
[sol,fval,eflag,output] = patternsearch(fun,...
    x0,[],[],[],[],lb,ub,[],optsc)

patternsearch stopped because the mesh size was less than options.MeshTolerance.

sol = 1×2
10^-5 ×

    0.9825         0

fval = 
1.3278e-09

eflag = 
1

output = struct with fields:
         function: @(x)sawtoothxy(x(1),x(2))
      problemtype: 'boundconstraints'
       pollmethod: 'gpspositivebasis2n'
    maxconstraint: 0
     searchmethod: []
       iterations: 52
        funccount: 168
         meshsize: 9.5367e-07
         rngstate: [1x1 struct]
          message: 'patternsearch stopped because the mesh size was less than options.MeshTolerance.'

L'algorithme "classic" atteint la solution globale en 52 itérations et 168 évaluations de fonctions.

Essayez l'algorithme "nups".

rng default % For reproducibility
optsn = optimoptions("patternsearch",Algorithm="nups");
[sol,fval,eflag,output] = patternsearch(fun,...
    x0,[],[],[],[],lb,ub,[],optsn)

patternsearch stopped because the mesh size was less than options.MeshTolerance.

sol = 1×2

    6.3204   15.0000

fval = 
85.9256

eflag = 
1

output = struct with fields:
         function: @(x)sawtoothxy(x(1),x(2))
      problemtype: 'boundconstraints'
       pollmethod: 'nups'
    maxconstraint: 0
     searchmethod: []
       iterations: 29
        funccount: 88
         meshsize: 7.1526e-07
         rngstate: [1x1 struct]
          message: 'patternsearch stopped because the mesh size was less than options.MeshTolerance.'

Cette fois, le solveur atteint une solution locale en seulement 29 itérations et 88 évaluations de fonctions, mais la solution n'est pas la solution globale.

Essayez d'utiliser l'algorithme "nups-mads", qui ne prend aucune mesure dans les directions des coordonnées.

rng default % For reproducibility
optsm = optimoptions("patternsearch",Algorithm="nups-mads");
[sol,fval,eflag,output] = patternsearch(fun,...
    x0,[],[],[],[],lb,ub,[],optsm)

patternsearch stopped because the mesh size was less than options.MeshTolerance.

sol = 1×2
10^-4 ×

   -0.5275    0.0806

fval = 
1.5477e-08

eflag = 
1

output = struct with fields:
         function: @(x)sawtoothxy(x(1),x(2))
      problemtype: 'boundconstraints'
       pollmethod: 'nups-mads'
    maxconstraint: 0
     searchmethod: []
       iterations: 55
        funccount: 189
         meshsize: 9.5367e-07
         rngstate: [1x1 struct]
          message: 'patternsearch stopped because the mesh size was less than options.MeshTolerance.'

Cette fois, le solveur atteint la solution globale en 55 itérations et 189 évaluations de fonctions, ce qui est similaire à l'algorithme 'classic'.

Recherche de patterns avec des options n'utilisant pas les valeurs par défaut

Définissez des options pour observer la progression du processus de solution patternsearch.

Créez la fonction objectif à deux variables suivante. Sur votre chemin MATLAB^®, enregistrez le code suivant dans un fichier nommé psobj.m.

function y = psobj(x)

y = exp(-x(1)^2-x(2)^2)*(1+5*x(1) + 6*x(2) + 12*x(1)*cos(x(2)));

Définissez la fonction objectif sur @psobj.

fun = @psobj;

Définissez options pour donner un affichage itératif et pour tracer la fonction objectif à chaque itération.

options = optimoptions('patternsearch','Display','iter','PlotFcn',@psplotbestf);

Trouver le minimum non contraint de l'objectif à partir du point [0,0].

x0 = [0,0];
A = [];
b = [];
Aeq = [];
beq = [];
lb = [];
ub = [];
nonlcon = [];
x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options)

Iter     f-count          f(x)      MeshSize     Method
    0        1              1             1      
    1        4       -5.88607             2     Successful Poll
    2        8       -5.88607             1     Refine Mesh
    3       12       -5.88607           0.5     Refine Mesh
    4       16       -5.88607          0.25     Refine Mesh

(output trimmed)

   63      218       -7.02545     1.907e-06     Refine Mesh
   64      221       -7.02545     3.815e-06     Successful Poll
   65      225       -7.02545     1.907e-06     Refine Mesh
   66      229       -7.02545     9.537e-07     Refine Mesh
Optimization terminated: mesh size less than options.MeshTolerance.

x =

   -0.7037   -0.1860

Obtenir la valeur de la fonction et le point de minimisation

Ouvrir le script

Trouvez une valeur minimale d'une fonction et indiquez à la fois l'emplacement et la valeur du minimum.

Créez la fonction objectif à deux variables suivante. Sur votre chemin MATLAB ®, enregistrez le code suivant dans un fichier nommé psobj.m.

function y = psobj(x)

y = exp(-x(1)^2-x(2)^2)*(1+5*x(1) + 6*x(2) + 12*x(1)*cos(x(2)));

Définissez la fonction objectif sur @psobj.

fun = @psobj;

Trouver le minimum non contraint de l'objectif, en partant du point [0,0]. Renvoie à la fois l'emplacement du minimum, x, et la valeur de fun(x).

x0 = [0,0];
[x,fval] = patternsearch(fun,x0)

patternsearch stopped because the mesh size was less than options.MeshTolerance.

x =

   -0.7037   -0.1860


fval =

   -7.0254

Obtenir toutes les sorties

Ouvrir le script

Pour examiner le processus de solution patternsearch, obtenez toutes les sorties.

Créez la fonction objectif à deux variables suivante. Sur votre chemin MATLAB ®, enregistrez le code suivant dans un fichier nommé psobj.m.

function y = psobj(x)

y = exp(-x(1)^2-x(2)^2)*(1+5*x(1) + 6*x(2) + 12*x(1)*cos(x(2)));

Définissez la fonction objectif sur @psobj.

fun = @psobj;

Trouver le minimum non contraint de l'objectif, en partant du point [0,0]. Renvoie la solution, x, la valeur de la fonction objectif à la solution, fun(x), l'exit flag et la structure de sortie.

x0 = [0,0];
[x,fval,exitflag,output] = patternsearch(fun,x0)

patternsearch stopped because the mesh size was less than options.MeshTolerance.

x =

   -0.7037   -0.1860


fval =

   -7.0254


exitflag =

     1


output = 

  struct with fields:

         function: @psobj
      problemtype: 'unconstrained'
       pollmethod: 'gpspositivebasis2n'
    maxconstraint: []
     searchmethod: []
       iterations: 66
        funccount: 229
         meshsize: 9.5367e-07
         rngstate: [1x1 struct]
          message: 'patternsearch stopped because the mesh size was less than options.MeshTolerance.'

Le exitflag est 1, indiquant la convergence vers un minimum local.

La structure output inclut des informations telles que le nombre d'itérations nécessaires à patternsearch et le nombre d'évaluations de fonctions. Comparez cette structure de sortie avec les résultats de Recherche de patterns avec des options n'utilisant pas les valeurs par défaut. Dans cet exemple, vous obtenez certaines de ces informations, mais vous n’obtenez pas, par exemple, le nombre d’évaluations de fonctions.

Arguments d'entrée

réduire tout

`fun` — Fonction à minimiser
handle de fonction | nom de la fonction

Fonction à minimiser, spécifiée comme un handle de fonction ou un nom de fonction. La fonction fun accepte un vecteur x et renvoie un scalaire réel f, qui est la fonction objectif évaluée à x.

Vous pouvez spécifier fun comme handle de fonction pour un fichier

x = patternsearch(@myfun,x0)

Ici, myfun est une fonction MATLAB telle que

function f = myfun(x)
f = ...            % Compute function value at x

fun peut également être un handle de fonction pour une fonction anonyme

x = patternsearch(@(x)norm(x)^2,x0,A,b);

Exemple : fun = @(x)sin(x(1))*cos(x(2))

Types de données : char | function_handle | string

`x0` — Point de départ
vecteur réel

Point initial, spécifié comme un vecteur réel. patternsearch utilise le nombre d'éléments dans x0 pour déterminer le nombre de variables que fun accepte.

Exemple : x0 = [1,2,3,4]

Types de données : double

`A` — Contraintes d'inégalités linéaires
matrice réelle

Contraintes d'inégalités linéaires, spécifiées sous forme de matrice réelle. A est une matrice M par nvars, où M est le nombre d'inégalités.

A encode les inégalités linéaires M

A*x <= b,

où x est le vecteur colonne de nvars variables x(:), et b est un vecteur colonne avec M éléments.

Par exemple, pour préciser

x₁ + 2 x₂ ≤ 10
3 x₁ + 4 x₂ ≤ 20
5 x₁ + 6 x₂ ≤ 30,

donnez ces contraintes :

A = [1,2;3,4;5,6];
b = [10;20;30];

Exemple : Pour spécifier que la somme des variables de contrôle est égale à 1 ou moins, donnez les contraintes A = ones(1,N) et b = 1.

Types de données : double

`b` — Contraintes d'inégalités linéaires
vecteur réel

Contraintes d'inégalité linéaire, spécifiées comme un vecteur réel. b est un vecteur d'éléments M lié à la matrice A. Si vous passez b comme vecteur de ligne, les solveurs convertissent en interne b en vecteur de colonne b(:).

b encode les inégalités linéaires M

A*x <= b,

où x est le vecteur colonne de N variables x(:), et A est une matrice de taille M-par-N.

Par exemple, pour préciser

x₁ + 2 x₂ ≤ 10
3 x₁ + 4 x₂ ≤ 20
5 x₁ + 6 x₂ ≤ 30,

donnez ces contraintes :

A = [1,2;3,4;5,6];
b = [10;20;30];

Exemple : Pour spécifier que la somme des variables de contrôle est égale à 1 ou moins, donnez les contraintes A = ones(1,N) et b = 1.

Types de données : double

`Aeq` — Contraintes d'égalité linéaire
matrice réelle

Contraintes d'égalité linéaire, spécifiées sous forme de matrice réelle. Aeq est une matrice Me par nvars, où Me est le nombre d'égalités.

Aeq encode les égalités linéaires Me

Aeq*x = beq,

où x est le vecteur colonne de N variables x(:), et beq est un vecteur colonne avec Me éléments.

Par exemple, pour préciser

x₁ + 2 x₂ + 3 x₃ = 10
2 x₁ + 4 x₂ + x₃ = 20,

donnez ces contraintes :

Aeq = [1,2,3;2,4,1];
beq = [10;20];

Exemple : Pour spécifier que la somme des variables de contrôle est égale à 1, donnez les contraintes Aeq = ones(1,N) et beq = 1.

Types de données : double

`beq` — Contraintes d'égalité linéaire
vecteur réel

Contraintes d'égalité linéaire, spécifiées comme un vecteur réel. beq est un vecteur d'éléments Me lié à la matrice Aeq. Si vous passez beq comme vecteur de ligne, les solveurs convertissent en interne beq en vecteur de colonne beq(:).

beq encode les égalités linéaires Me

Aeq*x = beq,

où x est le vecteur colonne de N variables x(:), et Aeq est une matrice de taille Meq-par-N.

Par exemple, pour préciser

x₁ + 2 x₂ + 3 x₃ = 10
2 x₁ + 4 x₂ + x₃ = 20,

donnez ces contraintes :

Aeq = [1,2,3;2,4,1];
beq = [10;20];

Exemple : Pour spécifier que la somme des variables de contrôle est égale à 1, donnez les contraintes Aeq = ones(1,N) et beq = 1.

Types de données : double

`lb` — Limites inférieures
vecteur réel | tableau réel

Limites inférieures, spécifiées sous forme de vecteur réel ou de tableau réel. Si le nombre d'éléments dans x0 est égal à celui de lb, alors lb spécifie que

x(i) >= lb(i)

pour tous les i.

Si numel(lb) < numel(x0), alors lb spécifie que

x(i) >= lb(i)

pour

1 <= i <= numel(lb)

Dans ce cas, les solveurs émettent un avertissement.

Exemple : Pour spécifier que toutes les variables de contrôle sont positives, lb = zeros(size(x0))

Types de données : double

`ub` — Limites supérieures
vecteur réel | tableau réel

Limites supérieures, spécifiées sous forme de vecteur réel ou de tableau réel. Si le nombre d'éléments dans x0 est égal à celui de ub, alors ub spécifie que

x(i) <= ub(i)

pour tous les i.

Si numel(ub) < numel(x0), alors ub spécifie que

x(i) <= ub(i)

pour

1 <= i <= numel(ub)

Dans ce cas, les solveurs émettent un avertissement.

Exemple : Pour spécifier que toutes les variables de contrôle sont inférieures à un, ub = ones(size(x0))

Types de données : double

`nonlcon` — Contraintes non linéaires
handle de fonction | nom de la fonction

Contraintes non linéaires, spécifiées sous forme de handle de fonction ou de nom de fonction. nonlcon est une fonction qui accepte un vecteur ou un tableau x et renvoie deux tableaux, c(x) et ceq(x).

c(x) est le tableau des contraintes d'inégalité non linéaires à x. patternsearch tente de satisfaire
c(x) <= 0
pour toutes les entrées de c.
ceq(x) est le tableau des contraintes d'égalité non linéaires à x. patternsearch tente de satisfaire
ceq(x) = 0
pour toutes les entrées de ceq.

Par exemple,

x = patternsearch(@myfun,x0,A,b,Aeq,beq,lb,ub,@mycon)

où mycon est une fonction MATLAB telle que

function [c,ceq] = mycon(x)
c = ...     % Compute nonlinear inequalities at x.
ceq = ...   % Compute nonlinear equalities at x.

Pour plus d'informations, voir Nonlinear Constraints.

Types de données : char | function_handle | string

`options` — Options d'optimisation
objet renvoyé par `optimoptions` | structure

Options d'optimisation, spécifiées sous la forme d'un objet renvoyé par optimoptions (recommandé) ou d'une structure.

Le tableau suivant décrit les options d'optimisation. optimoptions masque les options affichées en italique ; voir Options that optimoptions Hides. {} indique la valeur par défaut. Voir les détails de l'option dans Pattern Search Options.

Options pour patternsearch

Option	Description	Valeurs
`Algorithm`	Algorithme utilisé par `patternsearch`. Le paramètre `Algorithm` affecte les options disponibles. Pour plus de détails sur l'algorithme, voir How Pattern Search Polling Works et Nonuniform Pattern Search (NUPS) Algorithm. Pour des exemples d’effets d’algorithme, voir Explore patternsearch Algorithms et Explore patternsearch Algorithms in Optimize Live Editor Task.	`{"classic"}` \| `"nups"` \| `"nups-gps"` \| `"nups-mads"`
Cache	Avec `Cache` défini sur `"on"`, `patternsearch` conserve un historique des points de maillage qu'il interroge. Lors des itérations suivantes, `patternsearch` n'interroge pas les points proches de ceux déjà interrogés. Utilisez cette option si `patternsearch` s'exécute lentement lors du calcul de la fonction objectif. Si la fonction objectif est stochastique, n'utilisez pas cette option. Remarque `Cache` ne fonctionne pas lorsque vous exécutez le solveur en parallèle.	`"on"` \| `{"off"}`
Taille du cache	Taille de l'historique.	Scalaire non négatif \| `{1e4}`
CacheTol	La plus grande distance entre le point de maillage actuel et n'importe quel point de l'historique afin que `patternsearch` évite d'interroger le point actuel. Utiliser si l'option `Cache` est définie sur `"on"`.	Scalaire non négatif \| `{eps}`
`ConstraintTolerance`	Tolérance aux contraintes. Pour une structure d'options, utilisez `TolCon`.	Scalaire positif \| `{1e-6}`
`Display`	Niveau d'affichage, c'est-à-dire la quantité d'informations que `patternsearch` renvoie à la ligne de commande pendant le processus de résolution.	`"off"` \| `"iter"` \| `"diagnose"` \| `{"final"}`
`FunctionTolerance`	Tolérance sur la fonction. Les itérations s'arrêtent si le changement de valeur de la fonction est inférieur à `FunctionTolerance` et la taille du maillage est inférieure à `StepTolerance`. Cette option ne s'applique pas à l'interrogation MADS (recherche directe adaptative en maillage). Pour une structure d'options, utilisez `TolFun`.	Scalaire non négatif \| `{1e-6}`
`InitialMeshSize`	Taille de maillage initiale pour l'algorithme. Voir How Pattern Search Polling Works.	Scalaire positif \| `{1.0}`
InitialPenalty	Valeur initiale du paramètre de pénalité. Voir Nonlinear Constraint Solver Algorithm for Pattern Search.	Scalaire positif \| `{10}`
`MaxFunctionEvaluations`	Nombre maximal d'évaluations de fonctions objectif. Pour une structure d'options, utilisez `MaxFunEvals`.	Entier non négatif \| `{"2000*numberOfVariables"}`, où `numberOfVariables` est le nombre de variables du problème
`MaxIterations`	Nombre maximal d'itérations. Pour une structure d'options, utilisez `MaxIter`.	Entier non négatif \| `{"100*numberOfVariables"}`, où `numberOfVariables` est le nombre de variables du problème
Taille maximale du maillage	Taille de maillage maximale utilisée dans une étape de sondage ou de recherche. Voir How Pattern Search Polling Works.	Scalaire non négatif \| `{Inf}`
`MaxTime`	Temps total (en secondes) autorisé pour l'optimisation. Pour une structure d'options, utilisez `TimeLimit`.	Scalaire non négatif \| `{Inf}`
`MeshContractionFactor`	Facteur de contraction du maillage pour une itération infructueuse. Cette option s'applique uniquement lorsque `Algorithm` est `"classic"`. Pour une structure d'options, utilisez `MeshContraction`.	Scalaire positif \| `{0.5}`
`MeshExpansionFactor`	Facteur d'expansion du maillage pour une itération réussie. Cette option s'applique uniquement lorsque `Algorithm` est `"classic"`. Pour une structure d'options, utilisez `MeshExpansion`.	Scalaire positif \| `{2.0}`
Rotation du maillage	Drapeau pour faire pivoter le motif avant de déclarer un point comme optimal. Voir Mesh Options. Cette option s'applique uniquement lorsque `Algorithm` est `"classic"`.	`"off"` \| `{"on"}`
`MeshTolerance`	Tolérance sur la taille des mailles. Pour une structure d'options, utilisez `TolMesh`.	Scalaire non négatif \| `{1e-6}`
`OutputFcn`	Fonction appelée par une fonction d'optimisation à chaque itération. Spécifiez comme un handle de fonction ou un cell array de handles de fonction. Pour une structure d'options, utilisez `OutputFcns`.	Handle de fonction ou cell array de handles de fonction \| `{[]}`
PenaltyFactor	Paramètre de mise à jour de pénalité. Voir Nonlinear Constraint Solver Algorithm for Pattern Search.	Scalaire positif \| `{100}`
`PlotFcn`	Graphiques de sortie de la recherche de modèle. Spécifiez comme nom d'une fonction de tracé prédéfinie, d'un handle de fonction ou d'un cell array de noms de fonctions de tracé prédéfinies ou de handles de fonction. Pour une structure d'options, utilisez `PlotFcns`.	`{[]}` \| `"psplotbestf"` \| `"psplotfuncount"` \| `"psplotmeshsize"` \| `"psplotbestx"` \| `"psplotmaxconstr"` \| fonction de tracé personnalisée
PlotInterval	Nombre d'itérations pour les tracés. `1` signifie tracer à chaque itération, `2` signifie tracer toutes les deux itérations, et ainsi de suite.	entier positif \| `{1}`
`PollMethod`	Stratégie de sondage utilisée dans la recherche de modèles. Cette option s'applique uniquement lorsque `Algorithm` est `"classic"`. Remarque Vous ne pouvez pas utiliser l’interrogation MADS lorsque le problème présente des contraintes d’égalité linéaire.	`{"GPSPositiveBasis2N"}` `\|` `"GPSPositiveBasisNp1"` `\|` `"GSSPositiveBasis2N"` `\|` `"GSSPositiveBasisNp1"` `\|` `"MADSPositiveBasis2N"` `\|` `"MADSPositiveBasisNp1"`
`PollOrderAlgorithm`	Ordre des directions du sondage dans la recherche de modèle. Cette option s'applique uniquement lorsque `Algorithm` est `"classic"`. Pour une structure d'options, utilisez `PollingOrder`.	`"Random"` \| `"Success"` \| `{"Consecutive"}`
`ScaleMesh`	Mise à l'échelle automatique des variables. Pour une structure d'options, utilisez `ScaleMesh` = `"on"` ou `"off"`.	`{true}`\| `false`
`SearchFcn`	Type de recherche utilisé dans la recherche de modèle. Spécifier comme un nom ou un handle de fonction. Pour une structure d'options, utilisez `SearchMethod`.	`"GPSPositiveBasis2N" \| "GPSPositiveBasisNp1" \| "GSSPositiveBasis2N" \| "GSSPositiveBasisNp1" \| "MADSPositiveBasis2N" \| "MADSPositiveBasisNp1" \| "searchga" \| "searchlhs" \| "searchneldermead" \| "rbfsurrogate" \| {[]} \|` fonction de recherche personnalisée
`StepTolerance`	Tolérance sur la variable. Les itérations s'arrêtent si le changement de position et la taille du maillage sont inférieurs à `StepTolerance`. Cette option ne s'applique pas à l'interrogation MADS. Pour une structure d'options, utilisez `TolX`.	Scalaire non négatif \| `{1e-6}`
TolBind	Tolérance de liaison. Voir Constraint Parameters.	Scalaire non négatif \| `{1e-3}`
`UseCompletePoll`	Drapeau pour compléter le sondage autour du point actuel. Voir How Pattern Search Polling Works. Cette option s'applique uniquement lorsque `Algorithm` est `"classic"`. Remarque Pour l'algorithme `"classic"`, vous devez définir `UseCompletePoll` sur `true` pour l'interrogation vectorisée ou parallèle. De même, définissez `UseCompleteSearch` sur `true` pour une recherche vectorisée ou parallèle. À partir de R2019a, lorsque vous définissez l'option `UseParallel` sur `true`, `patternsearch` remplace en interne le paramètre `UseCompletePoll` sur `true` afin que la fonction interroge en parallèle. Pour une structure d'options, utilisez `CompletePoll` = `"on"` ou `"off"`.	`true` \| `{false}`
`UseCompleteSearch`	Drapeau pour terminer la recherche autour du point actuel lorsque la méthode de recherche est une méthode de sondage. Voir Searching and Polling. Cette option s'applique uniquement lorsque `Algorithm` est `"classic"`. Remarque Pour l'algorithme `"classic"`, vous devez définir `UseCompleteSearch` sur `true` pour une recherche vectorisée ou parallèle. Pour une structure d'options, utilisez `CompleteSearch` = `"on"` ou `"off"`.	`true` \| `{false}`
`UseParallel`	Drapeau pour calculer les fonctions de contraintes objectives et non linéaires en parallèle. Voir Vectorized and Parallel Options et How to Use Parallel Processing in Global Optimization Toolbox. Remarque Pour l'algorithme `"classic"`, vous devez définir `UseCompletePoll` sur `true` pour l'interrogation vectorisée ou parallèle. De même, définissez `UseCompleteSearch` sur `true` pour une recherche vectorisée ou parallèle. À partir de R2019a, lorsque vous définissez l'option `UseParallel` sur `true`, `patternsearch` remplace en interne le paramètre `UseCompletePoll` sur `true` afin que la fonction interroge en parallèle. Remarque `Cache` ne fonctionne pas lorsque vous exécutez le solveur en parallèle.	`true` \| `{false}`
`UseVectorized`	Spécifie si les fonctions sont vectorisées. Voir Vectorized and Parallel Options et Vectorize the Objective and Constraint Functions. Remarque Pour l'algorithme `"classic"`, vous devez définir `UseCompletePoll` sur `true` pour l'interrogation vectorisée ou parallèle. De même, définissez `UseCompleteSearch` sur `true` pour une recherche vectorisée ou parallèle. Pour une structure d'options, utilisez `Vectorized` = `"on"` ou `"off"`.	`true` \| `{false}`

Exemple : options = optimoptions("patternsearch",MaxIterations=150,MeshTolerance=1e-4)

`problem` — Structure du problème
structure

Structure du problème, spécifiée comme une structure avec les champs suivants :

objective — Fonction objectif
x0 — Point de départ
Aineq — Matrice pour les contraintes d'inégalité linéaire
bineq — Vecteur pour les contraintes d'inégalité linéaire
Aeq — Matrice pour les contraintes d'égalité linéaire
beq — Vecteur pour les contraintes d'égalité linéaire
lb — Borne inférieure pour x
ub — Borne supérieure pour x
nonlcon — Fonction de contrainte non linéaire
solver — 'patternsearch'
options — Options créées avec optimoptions ou une structure
rngstate — Champ facultatif pour réinitialiser l'état du générateur de nombres aléatoires

Note

Tous les champs de problem sont obligatoires sauf rngstate.

Types de données : struct

Arguments de sortie

réduire tout

`x` — Solution
vecteur réel

Solution, renvoyée sous forme de vecteur réel. La taille de x est la même que la taille de x0. Lorsque exitflag est positif, x est généralement une solution locale au problème.

`fval` — Valeur de la fonction objectif lors de la solution
nombre réel

Valeur de la fonction objectif à la solution, renvoyée sous forme de nombre réel. Généralement, fval = fun(x).

`exitflag` — Raison pour laquelle `patternsearch` s'est arrêté
entier

Raison de l'arrêt patternsearch, renvoyée sous forme d'entier.

Exit Flag	Signification
`1`	Sans contraintes non linéaires — La magnitude de la taille de la maille est inférieure à la tolérance spécifiée et la violation de contrainte est inférieure à `ConstraintTolerance`.
`1`	Avec des contraintes non linéaires — La grandeur de la mesure de complémentarité (définie après ce tableau) est inférieure à `sqrt(ConstraintTolerance)`, le sous-problème est résolu à l'aide d'un maillage plus fin que `MeshTolerance` et la violation de contrainte est inférieure à `ConstraintTolerance`.
`2`	La modification de `x` et la taille de la maille sont toutes deux inférieures à la tolérance spécifiée, et la violation de contrainte est inférieure à `ConstraintTolerance`.
`3`	La modification de `fval` et la taille de la maille sont toutes deux inférieures à la tolérance spécifiée, et la violation de contrainte est inférieure à `ConstraintTolerance`.
`4`	L'ampleur de l'étape est inférieure à la précision de la machine et la violation de contrainte est inférieure à `ConstraintTolerance`.
`0`	Le nombre maximal d'évaluations ou d'itérations de fonction est atteint.
`-1`	Optimisation terminée par une fonction de sortie ou une fonction de tracé.
`-2`	Aucun point possible n'a été trouvé.

Dans le solveur de contraintes non linéaires, la mesure de complémentarité est la norme du vecteur dont les éléments sont c_iλ_i, où c_i est la violation de contrainte d'inégalité non linéaire et λ_i est le multiplicateur de Lagrange correspondant.

`output` — Informations sur le processus d'optimisation
structure

Informations sur le processus d'optimisation, renvoyées sous forme de structure avec ces champs :

function — Fonction objectif.
problemtype — Type de problème, l'un des suivants :
- 'unconstrained'
- 'boundconstraints'
- 'linearconstraints'
- 'nonlinearconstr'
pollmethod — Technique de sondage.
searchmethod — Technique de recherche utilisée, le cas échéant.
iterations — Nombre total d'itérations.
funccount — Nombre total d’évaluations de fonctions.
meshsize — Taille de la maille à x.
maxconstraint — Violation de contrainte maximale, le cas échéant.
rngstate — État du générateur de nombres aléatoires MATLAB, juste avant le démarrage de l'algorithme. Vous pouvez utiliser les valeurs de rngstate pour reproduire la sortie lorsque vous utilisez une méthode de recherche aléatoire ou une méthode d'interrogation aléatoire. Voir Reproduce Results, qui décrit la même technique pour ga.
message — Raison pour laquelle l’algorithme s’est terminé.

Algorithmes

Par défaut et en l'absence de contraintes linéaires, patternsearch recherche un minimum basé sur un maillage adaptatif aligné avec les directions des coordonnées. Voir What Is Direct Search? et How Pattern Search Polling Works.

Lorsque vous définissez l'option Algorithm sur "nups" ou l'une de ses variantes, patternsearch utilise l'algorithme décrit dans Nonuniform Pattern Search (NUPS) Algorithm. Cet algorithme est différent de l'algorithme par défaut de plusieurs manières ; par exemple, il dispose de moins d'options à définir.

Fonctionnalités alternatives

Application

La tâche Optimize du Live Editor fournit une interface visuelle pour patternsearch.

Références

[1] Audet, Charles, and J. E. Dennis Jr. “Analysis of Generalized Pattern Searches.” SIAM Journal on Optimization. Volume 13, Number 3, 2003, pp. 889–903.

[2] Conn, A. R., N. I. M. Gould, and Ph. L. Toint. “A Globally Convergent Augmented Lagrangian Barrier Algorithm for Optimization with General Inequality Constraints and Simple Bounds.” Mathematics of Computation. Volume 66, Number 217, 1997, pp. 261–288.

[3] Abramson, Mark A. Pattern Search Filter Algorithms for Mixed Variable General Constrained Optimization Problems. Ph.D. Thesis, Department of Computational and Applied Mathematics, Rice University, August 2002.

[4] Abramson, Mark A., Charles Audet, J. E. Dennis, Jr., and Sebastien Le Digabel. “ORTHOMADS: A deterministic MADS instance with orthogonal directions.” SIAM Journal on Optimization. Volume 20, Number 2, 2009, pp. 948–966.

[5] Kolda, Tamara G., Robert Michael Lewis, and Virginia Torczon. “Optimization by direct search: new perspectives on some classical and modern methods.” SIAM Review. Volume 45, Issue 3, 2003, pp. 385–482.

[6] Kolda, Tamara G., Robert Michael Lewis, and Virginia Torczon. “A generating set direct search augmented Lagrangian algorithm for optimization with a combination of general and linear constraints.” Technical Report SAND2006-5315, Sandia National Laboratories, August 2006.

[7] Lewis, Robert Michael, Anne Shepherd, and Virginia Torczon. “Implementing generating set search methods for linearly constrained minimization.” SIAM Journal on Scientific Computing. Volume 29, Issue 6, 2007, pp. 2507–2530.

Capacités étendues

développer tout

Automatic Parallel Support
Accélérez le code en exécutant plusieurs calculs en parallèle avec Parallel Computing Toolbox™.

Pour exécuter en parallèle, définissez l'option 'UseParallel' sur true.

options = optimoptions('solvername','UseParallel',true)

Pour plus d'informations, voir How to Use Parallel Processing in Global Optimization Toolbox.

Historique des versions

Introduit avant R2006a

Voir aussi

ga | optimoptions | paretosearch | Optimize

patternsearch

Syntaxe

Description

Exemples

Minimisation de la recherche de modèles sans contrainte

Recherche de modèle avec une contrainte d'inégalité linéaire

Recherche de patterns avec limites

Recherche de modèles avec des contraintes non linéaires

Essayer différents algorithmes patternsearch

Recherche de patterns avec des options n'utilisant pas les valeurs par défaut

Obtenir la valeur de la fonction et le point de minimisation

Obtenir toutes les sorties

Arguments d'entrée

fun — Fonction à minimiser handle de fonction | nom de la fonction

x0 — Point de départ vecteur réel

A — Contraintes d'inégalités linéaires matrice réelle

b — Contraintes d'inégalités linéaires vecteur réel

Aeq — Contraintes d'égalité linéaire matrice réelle

beq — Contraintes d'égalité linéaire vecteur réel

lb — Limites inférieures vecteur réel | tableau réel

ub — Limites supérieures vecteur réel | tableau réel

nonlcon — Contraintes non linéaires handle de fonction | nom de la fonction

options — Options d'optimisation objet renvoyé par optimoptions | structure

problem — Structure du problème structure

Arguments de sortie

x — Solution vecteur réel

fval — Valeur de la fonction objectif lors de la solution nombre réel

exitflag — Raison pour laquelle patternsearch s'est arrêté entier

output — Informations sur le processus d'optimisation structure

Algorithmes

Fonctionnalités alternatives

Application

Références

Capacités étendues

Automatic Parallel Support Accélérez le code en exécutant plusieurs calculs en parallèle avec Parallel Computing Toolbox™.

Historique des versions

Voir aussi

Rubriques

Essayer différents algorithmes `patternsearch`

`fun` — Fonction à minimiser
handle de fonction | nom de la fonction

`x0` — Point de départ
vecteur réel

`A` — Contraintes d'inégalités linéaires
matrice réelle

`b` — Contraintes d'inégalités linéaires
vecteur réel

`Aeq` — Contraintes d'égalité linéaire
matrice réelle

`beq` — Contraintes d'égalité linéaire
vecteur réel

`lb` — Limites inférieures
vecteur réel | tableau réel

`ub` — Limites supérieures
vecteur réel | tableau réel

`nonlcon` — Contraintes non linéaires
handle de fonction | nom de la fonction

`options` — Options d'optimisation
objet renvoyé par `optimoptions` | structure

`problem` — Structure du problème
structure

`x` — Solution
vecteur réel

`fval` — Valeur de la fonction objectif lors de la solution
nombre réel

`exitflag` — Raison pour laquelle `patternsearch` s'est arrêté
entier

`output` — Informations sur le processus d'optimisation
structure

Automatic Parallel Support
Accélérez le code en exécutant plusieurs calculs en parallèle avec Parallel Computing Toolbox™.