Questa pagina è stata tradotta con la traduzione automatica. Fai clic qui per vedere l'ultima versione in inglese.

patternsearch

Trova il minimo della funzione usando la ricerca di pattern

comprimi tutto nella pagina

Sintassi

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(___)

Descrizione

x = patternsearch(fun,x0) trova un minimo locale, x, per la funzione handle fun che calcola i valori della funzione obiettivo. x0 è un vettore reale che specifica un punto iniziale per l'algoritmo di ricerca del pattern.

Nota

Passing Extra Parameters spiega come passare parametri aggiuntivi alla funzione obiettivo e alle funzioni di vincolo non lineare, se necessario.

esempio

x = patternsearch(fun,x0,A,b) minimizza fun soggetto alle disuguaglianze lineari A*x ≤ b . Vedi Linear Inequality Constraints .

esempio

x = patternsearch(fun,x0,A,b,Aeq,beq) minimizza fun soggetto alle uguaglianze lineari Aeq*x = beq e A*x ≤ b . Se non esistono disuguaglianze lineari, impostare A = [] e b = [] .

x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub) definisce un insieme di limiti inferiori e superiori sulle variabili di progettazione in x, in modo che la soluzione sia sempre compresa nell'intervallo lb ≤ x ≤ ub . Se non esistono uguaglianze lineari, impostare Aeq = [] e beq = [] . Se x(i) non ha un limite inferiore, impostare lb(i) = -Inf. Se x(i) non ha limite superiore, impostare ub(i) = Inf.

esempio

x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon) sottopone la minimizzazione alle disuguaglianze non lineari c(x) o alle uguaglianze ceq(x) definite in nonlcon . patternsearch ottimizza fun in modo tale che c(x) ≤ 0 e ceq(x) = 0 . Se non esistono limiti, impostare lb = [], ub = [] o entrambi.

esempio

x = patternsearch(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options) riduce al minimo fun con le opzioni di ottimizzazione specificate in options. Utilizzare optimoptions per impostare queste opzioni. Se non ci sono vincoli di disuguaglianza non lineare o di uguaglianza, impostare nonlcon = [] .

esempio

x = patternsearch(problem) trova il minimo per problem, una struttura descritta in problem .

[x,fval] = patternsearch(___), per qualsiasi sintassi, restituisce il valore della funzione obiettivo fun nella soluzione x .

esempio

[x,fval,exitflag,output] = patternsearch(___) restituisce inoltre exitflag, un valore che descrive la condizione di uscita di patternsearch, e una struttura output con informazioni sul processo di ottimizzazione.

esempio

Esempi

comprimi tutto

Minimizzazione della ricerca di pattern senza vincoli

Apri script

Ridurre al minimo un problema non vincolato utilizzando il risolutore patternsearch.

Creare la seguente funzione obiettivo a due variabili. Nel percorso MATLAB ®, salva il codice seguente in un file denominato 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)));

Impostare la funzione obiettivo su @psobj .

fun = @psobj;

Trova il minimo, partendo dal punto [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

Ricerca di pattern con un vincolo di disuguaglianza lineare

Apri script

Minimizzare una funzione soggetta ad alcuni vincoli di disuguaglianza lineare.

Creare la seguente funzione obiettivo a due variabili. Nel percorso MATLAB ®, salva il codice seguente in un file denominato 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)));

Impostare la funzione obiettivo su @psobj .

fun = @psobj;

Imposta i due vincoli di disuguaglianza lineare.

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

Trova il minimo, partendo dal punto [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

Ricerca di pattern con limiti

Apri script

Trova il minimo di una funzione che ha solo vincoli di limite.

Creare la seguente funzione obiettivo a due variabili. Nel percorso MATLAB ®, salva il codice seguente in un file denominato 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)));

Impostare la funzione obiettivo su @psobj .

fun = @psobj;

Trova il minimo quando $0 \le x(1) \le\infty$ e $-\infty \le x(2) \le -3$ .

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

Trova il minimo, partendo dal punto [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

Ricerca di pattern con vincoli non lineari

Apri script

Trova il minimo di una funzione soggetta a un vincolo di disuguaglianza non lineare.

Creare la seguente funzione obiettivo a due variabili. Nel percorso MATLAB ®, salva il codice seguente in un file denominato 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)));

Impostare la funzione obiettivo su @psobj .

fun = @psobj;

Creare il vincolo non lineare

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

Per farlo, nel percorso MATLAB, salva il codice seguente in un file denominato ellipsetilt.m .

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

Inizia patternsearch dal punto iniziale [-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

Prova diversi algoritmi `patternsearch`

Apri live script

A volte i diversi algoritmi patternsearch hanno comportamenti notevolmente diversi. Anche se può essere difficile prevedere quale algoritmo sia più efficace per risolvere un problema, è possibile provare facilmente algoritmi diversi. Per questo esempio, utilizzare la funzione obiettivo sawtoothxy, disponibile quando si esegue questo esempio e descritta e rappresentata graficamente in Trova i minimi globali o multipli locali.

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

Per vedere il comportamento dei diversi algoritmi quando si minimizza questa funzione obiettivo, è necessario impostare alcuni limiti asimmetrici. Imposta inoltre un punto iniziale x0 che sia lontano dalla vera soluzione sol = [0 0], dove sawtoothxy(0,0) = 0 .

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

Ridurre al minimo la funzione sawtoothxy utilizzando l'algoritmo "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'algoritmo "classic" raggiunge la soluzione globale in 52 iterazioni e 168 valutazioni di funzioni.

Prova l'algoritmo "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.'

Questa volta il risolutore raggiunge una soluzione locale in sole 29 iterazioni e 88 valutazioni di funzioni, ma la soluzione non è la soluzione globale.

Prova a usare l'algoritmo "nups-mads", che non esegue alcun passaggio nelle direzioni delle coordinate.

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

Questa volta, il risolutore raggiunge la soluzione globale in 55 iterazioni e 189 valutazioni di funzione, il che è simile all'algoritmo 'classic'.

Ricerca di modelli con opzioni non predefinite

Imposta le opzioni per osservare l'avanzamento del processo di soluzione patternsearch.

Creare la seguente funzione obiettivo a due variabili. Nel percorso MATLAB^®, salva il codice seguente in un file denominato 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)));

Impostare la funzione obiettivo su @psobj .

fun = @psobj;

Impostare options per ottenere una visualizzazione iterativa e per tracciare la funzione obiettivo a ogni iterazione.

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

Trova il minimo non vincolato dell'obiettivo a partire dal punto [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

Ottenere il valore della funzione e il punto di minimizzazione

Apri script

Trova il valore minimo di una funzione e riporta sia la posizione che il valore del minimo.

Creare la seguente funzione obiettivo a due variabili. Nel percorso MATLAB ®, salva il codice seguente in un file denominato 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)));

Impostare la funzione obiettivo su @psobj .

fun = @psobj;

Trova il minimo non vincolato dell'obiettivo, partendo dal punto [0,0] . Restituisce sia la posizione del minimo, x, sia il valore di 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

Ottieni tutti gli output

Apri script

Per esaminare il processo di soluzione patternsearch, ottenere tutti gli output.

Creare la seguente funzione obiettivo a due variabili. Nel percorso MATLAB ®, salva il codice seguente in un file denominato 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)));

Impostare la funzione obiettivo su @psobj .

fun = @psobj;

Trova il minimo non vincolato dell'obiettivo, partendo dal punto [0,0] . Restituisce la soluzione, x, il valore della funzione obiettivo nella soluzione, fun(x), il flag di uscita e la struttura di output.

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

exitflag è 1, che indica la convergenza verso un minimo locale.

La struttura output include informazioni quali il numero di iterazioni eseguite da patternsearch e il numero di valutazioni delle funzioni. Confrontare questa struttura di output con i risultati di Ricerca di modelli con opzioni non predefinite . In questo esempio si ottengono alcune di queste informazioni, ma non si ottiene, ad esempio, il numero di valutazioni della funzione.

Argomenti di input

comprimi tutto

`fun` — Funzione da minimizzare
funzione handle | nome della funzione

Funzione da ridurre al minimo, specificata come funzione handle o nome di funzione. La funzione fun accetta un vettore x e restituisce uno scalare reale f, che è la funzione obiettivo valutata in x.

È possibile specificare fun come funzione handle per un file.

x = patternsearch(@myfun,x0)

Qui, myfun è una funzione MATLAB come

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

fun può anche essere una funzione handle per una funzione anonima.

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

Esempio fun = @(x)sin(x(1))*cos(x(2))

Tipi di dati: char | function_handle | string

`x0` — Punto iniziale
vettore reale

Punto iniziale, specificato come vettore reale. patternsearch utilizza il numero di elementi in x0 per determinare il numero di variabili che fun accetta.

Esempio x0 = [1,2,3,4]

Tipi di dati: double

`A` — Vincoli di disuguaglianza lineare
matrice reale

Vincoli di disuguaglianza lineare, specificati come matrice reale. A è una matrice M per nvars, dove M è il numero di disuguaglianze.

A codifica le disuguaglianze lineari M

A*x <= b,

dove x è il vettore colonna delle variabili nvars x(:) e b è un vettore colonna con elementi M.

Ad esempio, per specificare

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

dare questi vincoli:

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

Esempio Per specificare che la somma delle variabili di controllo sia pari o inferiore a 1, specificare i vincoli A = ones(1,N) e b = 1.

Tipi di dati: double

`b` — Vincoli di disuguaglianza lineare
vettore reale

Vincoli di disuguaglianza lineare, specificati come vettore reale. b è un vettore di elementi M correlato alla matrice A. Se si passa b come vettore riga, i risolutori convertono internamente b nel vettore colonna b(:).

b codifica le disuguaglianze lineari M

A*x <= b,

dove x è il vettore colonna delle variabili N x(:) e A è una matrice di dimensione M per N .

Ad esempio, per specificare

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

dare questi vincoli:

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

Esempio Per specificare che la somma delle variabili di controllo sia pari o inferiore a 1, specificare i vincoli A = ones(1,N) e b = 1.

Tipi di dati: double

`Aeq` — Vincoli di uguaglianza lineare
matrice reale

Vincoli di uguaglianza lineare, specificati come matrice reale. Aeq è una matrice Me per nvars, dove Me è il numero di uguaglianze.

Aeq codifica le uguaglianze lineari Me

Aeq*x = beq,

dove x è il vettore colonna delle variabili N x(:) e beq è un vettore colonna con elementi Me.

Ad esempio, per specificare

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

dare questi vincoli:

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

Esempio Per specificare che la somma delle variabili di controllo sia 1, specificare i vincoli Aeq = ones(1,N) e beq = 1.

Tipi di dati: double

`beq` — Vincoli di uguaglianza lineare
vettore reale

Vincoli di uguaglianza lineare, specificati come vettore reale. beq è un vettore di elementi Me correlato alla matrice Aeq. Se si passa beq come vettore riga, i risolutori convertono internamente beq nel vettore colonna beq(:).

beq codifica le uguaglianze lineari Me

Aeq*x = beq,

dove x è il vettore colonna delle variabili N x(:) e Aeq è una matrice di dimensione Meq per N .

Ad esempio, per specificare

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

dare questi vincoli:

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

Esempio Per specificare che la somma delle variabili di controllo sia 1, specificare i vincoli Aeq = ones(1,N) e beq = 1.

Tipi di dati: double

`lb` — Limiti inferiori
vettore reale | matrice reale

Limiti inferiori, specificati come array reale o array reale. Se il numero di elementi in x0 è uguale a quello di lb, allora lb specifica che

x(i) >= lb(i)

per tutti i .

Se numel(lb) < numel(x0), allora lb specifica che

x(i) >= lb(i)

per

1 <= i <= numel(lb)

In questo caso, i risolutori emettono un avviso.

Esempio Per specificare che tutte le variabili di controllo sono positive, lb = zeros(size(x0))

Tipi di dati: double

`ub` — Limiti superiori
vettore reale | matrice reale

Limiti superiori, specificati come array reale o array reale. Se il numero di elementi in x0 è uguale a quello di ub, allora ub specifica che

x(i) <= ub(i)

per tutti i .

Se numel(ub) < numel(x0), allora ub specifica che

x(i) <= ub(i)

per

1 <= i <= numel(ub)

In questo caso, i risolutori emettono un avviso.

Esempio Per specificare che tutte le variabili di controllo sono minori di uno, ub = ones(size(x0))

Tipi di dati: double

`nonlcon` — Vincoli non lineari
funzione handle | nome della funzione

Vincoli non lineari, specificati come funzione handle o nome di funzione. nonlcon è una funzione che accetta un array x e restituisce due array, c(x) e ceq(x).

c(x) è la matrice dei vincoli di disuguaglianza non lineare in x . patternsearch tenta di soddisfare
c(x) <= 0
per tutte le voci di c .
ceq(x) è l'array di vincoli di uguaglianza non lineare in x . patternsearch tenta di soddisfare
ceq(x) = 0
per tutte le voci di ceq .

Per esempio,

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

dove mycon è una funzione MATLAB come

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

Per ulteriori informazioni, vedere Nonlinear Constraints .

Tipi di dati: char | function_handle | string

`options` — Opzioni di ottimizzazione
oggetto restituito da `optimoptions` | struttura

Opzioni di ottimizzazione, specificate come un oggetto restituito da optimoptions (consigliato) o una struttura.

Nella tabella seguente vengono descritte le opzioni di ottimizzazione. optimoptions nasconde le opzioni mostrate in corsivo; vedere Options that optimoptions Hides. {} indica il valore predefinito. Vedi i dettagli dell'opzione in Pattern Search Options .

Opzioni per patternsearch

Opzione	Descrizione	Valori
`Algorithm`	Algoritmo utilizzato da `patternsearch` . L'impostazione `Algorithm` influenza le opzioni disponibili. Per i dettagli sull'algoritmo, vedere How Pattern Search Polling Works e Nonuniform Pattern Search (NUPS) Algorithm. Per esempi di effetti dell'algoritmo, vedere Explore patternsearch Algorithms e Explore patternsearch Algorithms in Optimize Live Editor Task.	`{"classic"}` \| `"nups"` \| `"nups-gps"` \| `"nups-mads"`
Cache	Impostando `Cache` su `"on"`, `patternsearch` conserva una cronologia dei punti mesh interrogati. Nelle iterazioni successive, `patternsearch` non interroga i punti vicini a quelli già interrogati. Utilizzare questa opzione se `patternsearch` è lento durante il calcolo della funzione obiettivo. Se la funzione obiettivo è stocastica, non utilizzare questa opzione. Nota `Cache` non funziona quando si esegue il risolutore in parallelo.	`"on"` \| `{"off"}`
Dimensione cache	La dimensione della storia.	Scalare non negativo \| `{1e4}`
Totale cache	Distanza massima tra il punto mesh corrente e qualsiasi punto nella cronologia affinché `patternsearch` eviti di interrogare il punto corrente. Da utilizzare se l'opzione `Cache` è impostata su `"on"` .	Scalare non negativo \| `{eps}`
`ConstraintTolerance`	Tolleranza sui vincoli. Per una struttura di opzioni, utilizzare `TolCon` .	Scalare positivo \| `{1e-6}`
`Display`	Livello di visualizzazione, ovvero la quantità di informazioni che `patternsearch` restituisce alla riga di comando durante il processo di soluzione.	`"off"` \| `"iter"` \| `"diagnose"` \| `{"final"}`
`FunctionTolerance`	Tolleranza sulla funzione. Le iterazioni si interrompono se la modifica del valore della funzione è inferiore a `FunctionTolerance` e la dimensione della mesh è inferiore a `StepTolerance`. Questa opzione non si applica al polling MADS (ricerca diretta adattiva mesh). Per una struttura di opzioni, utilizzare `TolFun` .	Scalare non negativo \| `{1e-6}`
`InitialMeshSize`	Dimensione iniziale della mesh per l'algoritmo. Vedi How Pattern Search Polling Works .	Scalare positivo \| `{1.0}`
Penalità Iniziale	Valore iniziale del parametro di penalità. Vedi Nonlinear Constraint Solver Algorithm for Pattern Search .	Scalare positivo \| `{10}`
`MaxFunctionEvaluations`	Numero massimo di valutazioni della funzione obiettivo. Per una struttura di opzioni, utilizzare `MaxFunEvals` .	Intero non negativo \| `{"2000*numberOfVariables"}`, dove `numberOfVariables` è il numero di variabili del problema
`MaxIterations`	Numero massimo di iterazioni. Per una struttura di opzioni, utilizzare `MaxIter` .	Intero non negativo \| `{"100*numberOfVariables"}`, dove `numberOfVariables` è il numero di variabili del problema
DimensioneMassimaMesh	Dimensione massima della mesh utilizzata in una fase di sondaggio o ricerca. Vedi How Pattern Search Polling Works .	Scalare non negativo \| `{Inf}`
`MaxTime`	Tempo totale (in secondi) consentito per l'ottimizzazione. Per una struttura di opzioni, utilizzare `TimeLimit` .	Scalare non negativo \| `{Inf}`
`MeshContractionFactor`	Fattore di contrazione della mesh per un'iterazione non riuscita. Questa opzione si applica solo quando `Algorithm` è `"classic"` . Per una struttura di opzioni, utilizzare `MeshContraction` .	Scalare positivo \| `{0.5}`
`MeshExpansionFactor`	Fattore di espansione della mesh per un'iterazione riuscita. Questa opzione si applica solo quando `Algorithm` è `"classic"` . Per una struttura di opzioni, utilizzare `MeshExpansion` .	Scalare positivo \| `{2.0}`
Rotazione della maglia	Flag per ruotare il pattern prima di dichiarare un punto come ottimale. Vedi Mesh Options . Questa opzione si applica solo quando `Algorithm` è `"classic"` .	`"off"` \| `{"on"}`
`MeshTolerance`	Tolleranza sulla dimensione delle maglie. Per una struttura di opzioni, utilizzare `TolMesh` .	Scalare non negativo \| `{1e-6}`
`OutputFcn`	Funzione chiamata da una funzione di ottimizzazione a ogni iterazione. Specificare come funzione handle o come array di celle di funzione handle. Per una struttura di opzioni, utilizzare `OutputFcns` .	Funzione handle o matrice di celle di funzioni handle \| `{[]}`
Fattore di penalità	Parametro di aggiornamento della penalità. Vedi Nonlinear Constraint Solver Algorithm for Pattern Search .	Scalare positivo \| `{100}`
`PlotFcn`	Grafici dell'output della ricerca di pattern. Specificare come nome una funzione di grafico incorporata, una funzione handle o una matrice di celle di nomi di funzioni di grafico incorporate o funzioni handle. Per una struttura di opzioni, utilizzare `PlotFcns` .	`{[]}` \| `"psplotbestf"` \| `"psplotfuncount"` \| `"psplotmeshsize"` \| `"psplotbestx"` \| `"psplotmaxconstr"` \| funzione di tracciamento personalizzata
Intervallo di Trama	Numero di iterazioni per i grafici. `1` significa tracciare ogni iterazione, `2` significa tracciare ogni altra iterazione e così via.	intero positivo \| `{1}`
`PollMethod`	Strategia di polling utilizzata nella ricerca di pattern. Questa opzione si applica solo quando `Algorithm` è `"classic"` . Nota Non è possibile utilizzare il polling MADS quando il problema presenta vincoli di uguaglianza lineare.	`{"GPSPositiveBasis2N"}` `\|` `"GPSPositiveBasisNp1"` `\|` `"GSSPositiveBasis2N"` `\|` `"GSSPositiveBasisNp1"` `\|` `"MADSPositiveBasis2N"` `\|` `"MADSPositiveBasisNp1"`
`PollOrderAlgorithm`	Ordine delle direzioni del sondaggio nella ricerca del modello. Questa opzione si applica solo quando `Algorithm` è `"classic"` . Per una struttura di opzioni, utilizzare `PollingOrder` .	`"Random"` \| `"Success"` \| `{"Consecutive"}`
`ScaleMesh`	Scalabilità automatica delle variabili. Per una struttura di opzioni, utilizzare `ScaleMesh` = `"on"` o `"off"` .	`{true}`\| `false`
`SearchFcn`	Tipo di ricerca utilizzato nella ricerca di pattern. Specificare come nome o funzione handle. Per una struttura di opzioni, utilizzare `SearchMethod` .	`"GPSPositiveBasis2N" \| "GPSPositiveBasisNp1" \| "GSSPositiveBasis2N" \| "GSSPositiveBasisNp1" \| "MADSPositiveBasis2N" \| "MADSPositiveBasisNp1" \| "searchga" \| "searchlhs" \| "searchneldermead" \| "rbfsurrogate" \| {[]} \|` funzione di ricerca personalizzata
`StepTolerance`	Tolleranza sulla variabile. Le iterazioni si interrompono se sia la modifica di posizione sia la dimensione della mesh sono inferiori a `StepTolerance`. Questa opzione non si applica al polling MADS. Per una struttura di opzioni, utilizzare `TolX` .	Scalare non negativo \| `{1e-6}`
Legatura a Toll	Tolleranza vincolante. Vedi Constraint Parameters .	Scalare non negativo \| `{1e-3}`
`UseCompletePoll`	Segnala per completare il sondaggio attorno al punto corrente. Vedi How Pattern Search Polling Works . Questa opzione si applica solo quando `Algorithm` è `"classic"` . Nota Per l'algoritmo `"classic"`, è necessario impostare `UseCompletePoll` su `true` per il polling vettorizzato o parallelo. Allo stesso modo, impostare `UseCompleteSearch` su `true` per la ricerca parallela o vettorializzata. A partire da R2019a, quando si imposta l'opzione `UseParallel` su `true`, `patternsearch` sovrascrive internamente l'impostazione `UseCompletePoll` su `true` in modo che la funzione esegua il polling in parallelo. Per una struttura di opzioni, utilizzare `CompletePoll` = `"on"` o `"off"` .	`true` \| `{false}`
`UseCompleteSearch`	Flag per completare la ricerca attorno al punto corrente quando il metodo di ricerca è un metodo di sondaggio. Vedi Searching and Polling . Questa opzione si applica solo quando `Algorithm` è `"classic"` . Nota Per l'algoritmo `"classic"`, è necessario impostare `UseCompleteSearch` su `true` per la ricerca vettorizzata o parallela. Per una struttura di opzioni, utilizzare `CompleteSearch` = `"on"` o `"off"` .	`true` \| `{false}`
`UseParallel`	Flag per calcolare in parallelo le funzioni di vincolo oggettivo e non lineare. Vedere Vectorized and Parallel Options e How to Use Parallel Processing in Global Optimization Toolbox . Nota Per l'algoritmo `"classic"`, è necessario impostare `UseCompletePoll` su `true` per il polling vettorizzato o parallelo. Allo stesso modo, impostare `UseCompleteSearch` su `true` per la ricerca parallela o vettorializzata. A partire da R2019a, quando si imposta l'opzione `UseParallel` su `true`, `patternsearch` sovrascrive internamente l'impostazione `UseCompletePoll` su `true` in modo che la funzione esegua il polling in parallelo. Nota `Cache` non funziona quando si esegue il risolutore in parallelo.	`true` \| `{false}`
`UseVectorized`	Specifica se le funzioni sono vettorializzate. Vedere Vectorized and Parallel Options e Vectorize the Objective and Constraint Functions . Nota Per l'algoritmo `"classic"`, è necessario impostare `UseCompletePoll` su `true` per il polling vettorizzato o parallelo. Allo stesso modo, impostare `UseCompleteSearch` su `true` per la ricerca parallela o vettorializzata. Per una struttura di opzioni, utilizzare `Vectorized` = `"on"` o `"off"` .	`true` \| `{false}`

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

`problem` — Struttura del problema
struttura

Struttura del problema, specificata come una struttura con i seguenti campi:

objective — Funzione obiettivo
x0 — Punto di partenza
Aineq — Matrice per vincoli di disuguaglianza lineare
bineq — Vettore per vincoli di disuguaglianza lineare
Aeq — Matrice per vincoli di uguaglianza lineare
beq — Vettore per vincoli di uguaglianza lineare
lb — Limite inferiore per x
ub — Limite superiore per x
nonlcon — Funzione di vincolo non lineare
solver — 'patternsearch'
options — Opzioni create con optimoptions o una struttura
rngstate — Campo facoltativo per reimpostare lo stato del generatore di numeri casuali

Nota

Tutti i campi in problem sono obbligatori, tranne rngstate.

Tipi di dati: struct

Argomenti di output

comprimi tutto

`x` — Soluzione
vettore reale

Soluzione, restituita come vettore reale. La dimensione di x è la stessa di x0 . Quando exitflag è positivo, x è in genere una soluzione locale del problema.

`fval` — Valore della funzione obiettivo nella soluzione
numero reale

Valore della funzione obiettivo nella soluzione, restituito come numero reale. In genere, fval = fun(x) .

`exitflag` — Motivo per cui `patternsearch` si è fermato
numero intero

Motivo per cui patternsearch si è fermato, restituito come numero intero.

Bandiera di uscita	Significato
`1`	Senza vincoli non lineari — L'entità della dimensione della mesh è inferiore alla tolleranza specificata e la violazione del vincolo è inferiore a `ConstraintTolerance` .
`1`	Con vincoli non lineari — L'entità della misura di complementarietà (definita dopo questa tabella) è inferiore a `sqrt(ConstraintTolerance)`, il sottoproblema viene risolto utilizzando una mesh più fine di `MeshTolerance` e la violazione del vincolo è inferiore a `ConstraintTolerance`.
`2`	La modifica in `x` e la dimensione della mesh sono entrambe inferiori alla tolleranza specificata e la violazione del vincolo è inferiore a `ConstraintTolerance`.
`3`	La modifica in `fval` e la dimensione della mesh sono entrambe inferiori alla tolleranza specificata e la violazione del vincolo è inferiore a `ConstraintTolerance`.
`4`	L'entità del passo è inferiore alla precisione della macchina e la violazione del vincolo è inferiore a `ConstraintTolerance` .
`0`	È stato raggiunto il numero massimo di valutazioni o iterazioni della funzione.
`-1`	Ottimizzazione terminata da una funzione di output o da una funzione di grafico.
`-2`	Non è stato trovato alcun punto fattibile.

Nel risolutore di vincoli non lineari, la misura di complementarietà è la norma del vettore i cui elementi sono c_iλ_i, dove c_i è la violazione del vincolo di disuguaglianza non lineare e λ_i è il moltiplicatore di Lagrange corrispondente.

`output` — Informazioni sul processo di ottimizzazione
struttura

Informazioni sul processo di ottimizzazione, restituite come una struttura con questi campi:

function — Funzione obiettivo.
problemtype — Tipo di problema, uno dei:
- 'unconstrained'
- 'boundconstraints'
- 'linearconstraints'
- 'nonlinearconstr'
pollmethod — Tecnica di sondaggio.
searchmethod — Tecnica di ricerca utilizzata, se presente.
iterations — Numero totale di iterazioni.
funccount — Numero totale di valutazioni delle funzioni.
meshsize — Dimensione della maglia a x .
maxconstraint — Violazione massima del vincolo, se presente.
rngstate — Stato del generatore di numeri casuali MATLAB, appena prima dell'avvio dell'algoritmo. È possibile utilizzare i valori in rngstate per riprodurre l'output quando si utilizza un metodo di ricerca casuale o un metodo di sondaggio casuale. Vedere Reproduce Results, che illustra la stessa tecnica per ga.
message — Motivo per cui l'algoritmo è terminato.

Algoritmi

Per impostazione predefinita e in assenza di vincoli lineari, patternsearch cerca un minimo basato su una mesh adattiva allineata con le direzioni delle coordinate. Vedere What Is Direct Search? e How Pattern Search Polling Works .

Impostando l'opzione Algorithm su "nups" o una delle sue varianti, patternsearch utilizza l'algoritmo descritto in Nonuniform Pattern Search (NUPS) Algorithm. Questo algoritmo differisce dall'algoritmo predefinito per diversi motivi; ad esempio, ha meno opzioni da impostare.

Funzionalità alternativa

Applicazione

L'attività Ottimizza Live Editor fornisce un'interfaccia visiva per patternsearch .

Riferimenti

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

Funzionalità estese

Supporto parallelo automatico
Accelera il codice mediante esecuzione automatica dei calcoli in parallelo con Parallel Computing Toolbox™.

Per l'esecuzione in parallelo, impostare l'opzione 'UseParallel' su true.

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

Per ulteriori informazioni, vedere How to Use Parallel Processing in Global Optimization Toolbox .

Cronologia versioni

Introduzione prima di R2006a

Vedi anche

ga | optimoptions | paretosearch | Ottimizza

patternsearch

Sintassi

Descrizione

Esempi

Minimizzazione della ricerca di pattern senza vincoli

Ricerca di pattern con un vincolo di disuguaglianza lineare

Ricerca di pattern con limiti

Ricerca di pattern con vincoli non lineari

Prova diversi algoritmi patternsearch

Ricerca di modelli con opzioni non predefinite

Ottenere il valore della funzione e il punto di minimizzazione

Ottieni tutti gli output

Argomenti di input

fun — Funzione da minimizzare funzione handle | nome della funzione

x0 — Punto iniziale vettore reale

A — Vincoli di disuguaglianza lineare matrice reale

b — Vincoli di disuguaglianza lineare vettore reale

Aeq — Vincoli di uguaglianza lineare matrice reale

beq — Vincoli di uguaglianza lineare vettore reale

lb — Limiti inferiori vettore reale | matrice reale

ub — Limiti superiori vettore reale | matrice reale

nonlcon — Vincoli non lineari funzione handle | nome della funzione

options — Opzioni di ottimizzazione oggetto restituito da optimoptions | struttura

problem — Struttura del problema struttura

Argomenti di output

x — Soluzione vettore reale

fval — Valore della funzione obiettivo nella soluzione numero reale

exitflag — Motivo per cui patternsearch si è fermato numero intero

output — Informazioni sul processo di ottimizzazione struttura

Algoritmi

Funzionalità alternativa

Applicazione

Riferimenti

Funzionalità estese

Supporto parallelo automatico Accelera il codice mediante esecuzione automatica dei calcoli in parallelo con Parallel Computing Toolbox™.

Cronologia versioni

Vedi anche

Argomenti

Prova diversi algoritmi `patternsearch`

`fun` — Funzione da minimizzare
funzione handle | nome della funzione

`x0` — Punto iniziale
vettore reale

`A` — Vincoli di disuguaglianza lineare
matrice reale

`b` — Vincoli di disuguaglianza lineare
vettore reale

`Aeq` — Vincoli di uguaglianza lineare
matrice reale

`beq` — Vincoli di uguaglianza lineare
vettore reale

`lb` — Limiti inferiori
vettore reale | matrice reale

`ub` — Limiti superiori
vettore reale | matrice reale

`nonlcon` — Vincoli non lineari
funzione handle | nome della funzione

`options` — Opzioni di ottimizzazione
oggetto restituito da `optimoptions` | struttura

`problem` — Struttura del problema
struttura

`x` — Soluzione
vettore reale

`fval` — Valore della funzione obiettivo nella soluzione
numero reale

`exitflag` — Motivo per cui `patternsearch` si è fermato
numero intero

`output` — Informazioni sul processo di ottimizzazione
struttura

Supporto parallelo automatico
Accelera il codice mediante esecuzione automatica dei calcoli in parallelo con Parallel Computing Toolbox™.