Main Content

La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

lsqnonlin

Resolver problemas de mínimos cuadrados no lineales (ajuste de datos no lineales)

Descripción

Solver de mínimos cuadrados no lineales

Resuelve problemas de ajuste de curvas de mínimos cuadrados no lineales con el formato

minxf(x)22=minx(f1(x)2+f2(x)2+...+fn(x)2)

con límites inferiores y superiores opcionales lb y ub en los componentes de x.

x, lb y ub pueden ser vectores o matrices; consulte Argumentos de matriz.

Más que calcular el valor f(x)22 (la suma de cuadrados), lsqnonlin requiere que la función definida por el usuario calcule la función de valor vectorial

f(x)=[f1(x)f2(x)fn(x)].

ejemplo

x = lsqnonlin(fun,x0) comienza en el punto x0 y encuentra un mínimo de la suma de cuadrados de las funciones descritas en fun. La función fun debería devolver un vector (o arreglo) de valores y no la suma de cuadrados de los valores. (El algoritmo calcula implícitamente la suma de cuadrados de los componentes de fun(x)).

Nota

Pasar parámetros adicionales explica cómo pasar parámetros adicionales a la función vectorial fun(x), si fuera necesario.

ejemplo

x = lsqnonlin(fun,x0,lb,ub) define un conjunto de límites inferiores y superiores en las variables de diseño de x, de modo que la solución siempre se encuentra en el rango lb x ub. Puede fijar el componente de la solución x(i) especificando lb(i) = ub(i).

Nota

Si los límites de entrada especificados para un problema son inconsistentes, la salida x es x0 y las salidas resnorm y residual son [].

Los componentes de x0 que vulneran los límites lb ≤ x ≤ ub se restablecen al interior del cuadro definido por los límites. Los componentes que respetan los límites no se cambian.

ejemplo

x = lsqnonlin(fun,x0,lb,ub,options) minimiza con las opciones de optimización especificadas en options. Utilice optimoptions para configurar estas opciones. Pase matrices vacías para lb y ub si no existen límites.

x = lsqnonlin(problem) encuentra el mínimo para problem, una estructura descrita en problem.

ejemplo

[x,resnorm] = lsqnonlin(___), para cualquier argumento de entrada, devuelve la norma euclídea al cuadrado del valor residual en x: sum(fun(x).^2).

ejemplo

[x,resnorm,residual,exitflag,output] = lsqnonlin(___), devuelve adicionalmente el valor del residual fun(x) en la solución x, un valor exitflag que describe la condición de salida y una estructura output que contiene información sobre el proceso de optimización.

[x,resnorm,residual,exitflag,output,lambda,jacobian] = lsqnonlin(___) devuelve adicionalmente una estructura lambda cuyos campos contienen los multiplicadores de Lagrange en la solución x y la matriz jacobiana de fun en la solución x.

Ejemplos

contraer todo

Ajuste una curva de decaimiento exponencial simple a los datos.

Genere datos a partir de un modelo de decaimiento exponencial con ruido. El modelo es

y=exp(-1.3t)+ε,

con t en un rango de 0 a 3 y ruido ε distribuido normalmente con una media de 0 y una desviación estándar de 0,05.

rng default % for reproducibility
d = linspace(0,3);
y = exp(-1.3*d) + 0.05*randn(size(d));

El problema es: dados los datos (d, y), encuentre la tasa de decaimiento exponencial que mejor se ajuste a dichos datos.

Cree una función anónima que tome un valor de la tasa de decaimiento exponencial r y devuelva un vector de diferencias a partir del modelo con esa tasa de decaimiento y los datos.

fun = @(r)exp(-d*r)-y;

Encuentre el valor de la tasa de decaimiento óptima. Escoja arbitrariamente una conjetura inicial x0 = 4.

x0 = 4;
x = lsqnonlin(fun,x0)
Local minimum possible.

lsqnonlin stopped because the final change in the sum of squares relative to 
its initial value is less than the value of the function tolerance.
x = 1.2645

Represente los datos y la curva exponencial que mejor se ajuste.

plot(d,y,'ko',d,exp(-x*d),'b-')
legend('Data','Best fit')
xlabel('t')
ylabel('exp(-tx)')

Figure contains an axes object. The axes object contains 2 objects of type line. These objects represent Data, Best fit.

Encuentre el modelo que mejor se ajuste cuando algunos de los parámetros de ajuste tengan límites.

Encuentre la b de centrado y la a de escalado que mejor se ajusten a la función

aexp(-t)exp(-exp(-(t-b)))

a la densidad normal estándar,

12πexp(-t2/2).

Cree un vector t de puntos de datos y la correspondiente densidad normal en esos puntos.

t = linspace(-4,4);
y = 1/sqrt(2*pi)*exp(-t.^2/2);

Cree una función que evalúe la diferencia entre la función centrada y la función escalada a partir de la y normal, con x(1) como la a de escalado y x(2) como la b de centrado.

fun = @(x)x(1)*exp(-t).*exp(-exp(-(t-x(2)))) - y;

Encuentre el ajuste óptimo comenzando por x0 = [1/2,0], con la a de escalado entre 1/2 y 3/2, y la b de centrado entre –1 y 3.

lb = [1/2,-1];
ub = [3/2,3];
x0 = [1/2,0];
x = lsqnonlin(fun,x0,lb,ub)
Local minimum possible.

lsqnonlin stopped because the final change in the sum of squares relative to 
its initial value is less than the value of the function tolerance.
x = 1×2

    0.8231   -0.2444

Represente las dos funciones para comprobar la calidad del ajuste.

plot(t,y,'r-',t,fun(x)+y,'b-')
xlabel('t')
legend('Normal density','Fitted function')

Figure contains an axes object. The axes object contains 2 objects of type line. These objects represent Normal density, Fitted function.

Compare los resultados de un problema de ajuste de datos cuando se utilizan diferentes algoritmos lsqnonlin.

Suponga que tiene datos de tiempo de observación xdata y datos de respuesta observada ydata, y desea encontrar parámetros x(1) y x(2) para ajustar un modelo con el formato

ydata=x(1)exp(x(2)xdata).

Introduzca los tiempos de observación y las respuestas.

xdata = ...
 [0.9 1.5 13.8 19.8 24.1 28.2 35.2 60.3 74.6 81.3];
ydata = ...
 [455.2 428.6 124.1 67.3 43.2 28.1 13.1 -0.4 -1.3 -1.5];

Cree un modelo de decaimiento exponencial simple. El modelo calcula un vector de diferencias entre los valores previstos y los valores observados.

fun = @(x)x(1)*exp(x(2)*xdata)-ydata;

Ajuste el modelo utilizando el punto de inicio x0 = [100,-1]. En primer lugar, utilice el algoritmo predeterminado 'trust-region-reflective'.

x0 = [100,-1];
options = optimoptions(@lsqnonlin,'Algorithm','trust-region-reflective');
x = lsqnonlin(fun,x0,[],[],options)
Local minimum possible.

lsqnonlin stopped because the final change in the sum of squares relative to 
its initial value is less than the value of the function tolerance.
x = 1×2

  498.8309   -0.1013

Compruebe si existe alguna diferencia al utilizar el algoritmo 'levenberg-marquardt.

options.Algorithm = 'levenberg-marquardt';
x = lsqnonlin(fun,x0,[],[],options)
Local minimum possible.
lsqnonlin stopped because the relative size of the current step is less than
the value of the step size tolerance.
x = 1×2

  498.8309   -0.1013

Los dos algoritmos han encontrado la misma solución. Represente la solución y los datos.

plot(xdata,ydata,'ko')
hold on
tlist = linspace(xdata(1),xdata(end));
plot(tlist,x(1)*exp(x(2)*tlist),'b-')
xlabel xdata
ylabel ydata
title('Exponential Fit to Data')
legend('Data','Exponential Fit')
hold off

Figure contains an axes object. The axes object with title Exponential Fit to Data contains 2 objects of type line. These objects represent Data, Exponential Fit.

Encuentre la x que minimice

k=110(2+2k-ekx1-ekx2)2,

y encuentre el valor de la suma mínima de cuadrados.

Dado que lsqnonlin asume que la suma de cuadrados no se forma explícitamente en la función definida por el usuario, en su lugar, la función pasada a lsqnonlin debería calcular la función de valor vectorial

Fk(x)=2+2k-ekx1-ekx2,

para k=1 a 10 (es decir, F debería tener 10 componentes).

La función myfun, que calcula el vector F de 10 componentes, aparece al final de este ejemplo.

Encuentre el punto de minimización y el valor mínimo, comenzando en el punto x0 = [0.3,0.4].

x0 = [0.3,0.4];
[x,resnorm] = lsqnonlin(@myfun,x0)
Local minimum possible.
lsqnonlin stopped because the size of the current step is less than
the value of the step size tolerance.
x = 1×2

    0.2578    0.2578

resnorm = 124.3622

La salida resnorm es la norma residual cuadrada o la suma de los cuadrados de los valores de la función.

La siguiente función calcula la función objetivo de valor vectorial.

function F = myfun(x)
k = 1:10;
F = 2 + 2*k-exp(k*x(1))-exp(k*x(2));
end

Examine el proceso de resolución tanto en el momento en el que tiene lugar (estableciendo la opción Display en 'iter') como posteriormente (examinando la estructura output).

Suponga que tiene datos de tiempo de observación xdata y datos de respuesta observada ydata, y desea encontrar parámetros x(1) y x(2) para ajustar un modelo con el formato

ydata=x(1)exp(x(2)xdata).

Introduzca los tiempos de observación y las respuestas.

xdata = ...
 [0.9 1.5 13.8 19.8 24.1 28.2 35.2 60.3 74.6 81.3];
ydata = ...
 [455.2 428.6 124.1 67.3 43.2 28.1 13.1 -0.4 -1.3 -1.5];

Cree un modelo de decaimiento exponencial simple. El modelo calcula un vector de diferencias entre los valores previstos y los valores observados.

fun = @(x)x(1)*exp(x(2)*xdata)-ydata;

Ajuste el modelo utilizando el punto de inicio x0 = [100,-1]. Examine el proceso de resolución estableciendo la opción Display en 'iter'. Obtenga una estructura output para conseguir más información sobre el proceso de resolución.

x0 = [100,-1];
options = optimoptions('lsqnonlin','Display','iter');
[x,resnorm,residual,exitflag,output] = lsqnonlin(fun,x0,[],[],options);
                                         Norm of      First-order 
 Iteration  Func-count     f(x)          step          optimality
     0          3          359677                      2.88e+04
Objective function returned Inf; trying a new point...
     1          6          359677        11.6976       2.88e+04      
     2          9          321395            0.5       4.97e+04      
     3         12          321395              1       4.97e+04      
     4         15          292253           0.25       7.06e+04      
     5         18          292253            0.5       7.06e+04      
     6         21          270350          0.125       1.15e+05      
     7         24          270350           0.25       1.15e+05      
     8         27          252777         0.0625       1.63e+05      
     9         30          252777          0.125       1.63e+05      
    10         33          243877        0.03125       7.48e+04      
    11         36          243660         0.0625        8.7e+04      
    12         39          243276         0.0625          2e+04      
    13         42          243174         0.0625       1.14e+04      
    14         45          242999          0.125        5.1e+03      
    15         48          242661           0.25       2.04e+03      
    16         51          241987            0.5       1.91e+03      
    17         54          240643              1       1.04e+03      
    18         57          237971              2       3.36e+03      
    19         60          232686              4       6.04e+03      
    20         63          222354              8        1.2e+04      
    21         66          202592             16       2.25e+04      
    22         69          166443             32       4.05e+04      
    23         72          106320             64       6.68e+04      
    24         75         28704.7            128       8.31e+04      
    25         78         89.7947        140.674       2.22e+04      
    26         81         9.57381        2.02599            684      
    27         84         9.50489      0.0619927           2.27      
    28         87         9.50489    0.000462261         0.0114      

Local minimum possible.

lsqnonlin stopped because the final change in the sum of squares relative to 
its initial value is less than the value of the function tolerance.

Examine la estructura de salida para conseguir más información sobre el proceso de resolución.

output
output = struct with fields:
    firstorderopt: 0.0114
       iterations: 28
        funcCount: 87
     cgiterations: 0
        algorithm: 'trust-region-reflective'
         stepsize: 4.6226e-04
          message: 'Local minimum possible....'

Para la comparación, establezca la opción Algorithm en 'levenberg-marquardt'.

options.Algorithm = 'levenberg-marquardt';
[x,resnorm,residual,exitflag,output] = lsqnonlin(fun,x0,[],[],options);
                                        First-Order                    Norm of 
 Iteration  Func-count    Residual       optimality      Lambda           step
     0           3          359677        2.88e+04         0.01
Objective function returned Inf; trying a new point...
     1          13          340761        3.91e+04       100000       0.280777
     2          16          304661        5.97e+04        10000       0.373146
     3          21          297292        6.55e+04        1e+06      0.0589933
     4          24          288240        7.57e+04       100000      0.0645444
     5          28          275407        1.01e+05        1e+06      0.0741266
     6          31          249954        1.62e+05       100000       0.094571
     7          36          245896        1.35e+05        1e+07      0.0133606
     8          39          243846        7.26e+04        1e+06     0.00944311
     9          42          243568        5.66e+04       100000     0.00821622
    10          45          243424        1.61e+04        10000     0.00777936
    11          48          243322         8.8e+03         1000      0.0673933
    12          51          242408         5.1e+03          100       0.675209
    13          54          233628        1.05e+04           10        6.59804
    14          57          169089        8.51e+04            1        54.6992
    15          60         30814.7        1.54e+05          0.1        196.939
    16          63         147.496           8e+03         0.01        129.795
    17          66         9.51503             117        0.001        9.96069
    18          69         9.50489          0.0714       0.0001      0.0804859
    19          72         9.50489        5.12e-05        1e-05    5.07049e-05

Local minimum possible.
lsqnonlin stopped because the relative size of the current step is less than
the value of the step size tolerance.

El 'levenberg-marquardt' ha convergido con menos iteraciones, pero casi con las mismas evaluaciones de función:

output
output = struct with fields:
       iterations: 19
        funcCount: 72
         stepsize: 5.0705e-05
     cgiterations: []
    firstorderopt: 5.1213e-05
        algorithm: 'levenberg-marquardt'
          message: 'Local minimum possible....'

Argumentos de entrada

contraer todo

Función cuya suma de cuadrados está minimizada, especificada como un identificador de función o un nombre de función. fun es una función que acepta un arreglo x y devuelve un arreglo F, con las funciones objetivo evaluadas en x. La función fun puede especificarse como un identificador de función para un archivo:

x = lsqnonlin(@myfun,x0)

donde myfun es una función de MATLAB® como

function F = myfun(x)
F = ...            % Compute function values at x

fun también puede ser un identificador de función para una función anónima.

x = lsqnonlin(@(x)sin(x.*x),x0);

lsqnonlin pasa x a su función objetivo en forma de argumento x0. Por ejemplo, si x0 es un arreglo de 5 por 3, lsqnonlin pasa x a fun como un arreglo de 5 por 3.

Nota

La suma de los cuadrados no debería formarse explícitamente. En su lugar, la función debería devolver un vector de valores de función. Consulte Ejemplos.

Si la matriz jacobiana también puede calcularse y la opción 'SpecifyObjectiveGradient' es true, configurado mediante

options = optimoptions('lsqnonlin','SpecifyObjectiveGradient',true)

entonces la función fun debe devolver un segundo argumento de salida con el valor jacobiano J (una matriz) en x. Comprobando el valor de nargout, la función puede evitar calcular J cuando se llama a fun con solo un argumento de salida (en el caso en el que el algoritmo de optimización solo necesite el valor de F, pero no el de J).

function [F,J] = myfun(x)
F = ...          % Objective function values at x
if nargout > 1   % Two output arguments
   J = ...   % Jacobian of the function evaluated at x
end

Si fun devuelve un arreglo de m componentes y x tiene n elementos, donde n es el número de elementos de x0, la matriz jacobiana J es una matriz de m por n donde J(i,j) es la derivada parcial de F(i) con respecto a x(j). (La matriz jacobiana J es la traspuesta del gradiente de F).

Ejemplo: @(x)cos(x).*exp(-x)

Tipos de datos: char | function_handle | string

Punto inicial, especificado como un vector real o un arreglo real. Los solvers utilizan el número de elementos en x0 y el tamaño de x0 para determinar el número y el tamaño de las variables que fun acepta.

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

Tipos de datos: double

Límites inferiores, especificados como un vector real o un arreglo real. Si el número de elementos en x0 es igual al número de elementos en lb, entonces lb especifica que

x(i) >= lb(i) para todo i.

Si numel(lb) < numel(x0), entonces lb especifica que

x(i) >= lb(i) para 1 <= i <= numel(lb).

Si lb tiene menos elementos que x0, los solvers emiten una advertencia.

Ejemplo: Para especificar que todos los componentes de x son positivos, utilice lb = zeros(size(x0)).

Tipos de datos: double

Límites superiores, especificados como un vector real o un arreglo real. Si el número de elementos en x0 es igual al número de elementos en ub, entonces ub especifica que

x(i) <= ub(i) para todo i.

Si numel(ub) < numel(x0), entonces ub especifica que

x(i) <= ub(i) para 1 <= i <= numel(ub).

Si ub tiene menos elementos que x0, los solvers emiten una advertencia.

Ejemplo: Para especificar que todos los componentes de x son menores que 1, utilice ub = ones(size(x0)).

Tipos de datos: double

Opciones de optimización, especificadas como la salida de optimoptions o una estructura como la que devuelve optimset.

Algunas opciones son aplicables a todos los algoritmos y otras son relevantes para algoritmos particulares. Consulte Referencia de opciones de optimización para ver información detallada.

Algunas opciones no aparecen en la visualización optimoptions. Estas opciones se muestran en cursiva en la siguiente tabla. Para obtener más detalles, consulte Visualizar opciones.

Todos los algoritmos

Algorithm

Escoja entre 'trust-region-reflective' (opción predeterminada) y 'levenberg-marquardt'.

La opción Algorithm especifica una preferencia sobre qué algoritmo utilizar. Se trata únicamente de una preferencia, ya que se deben cumplir ciertas condiciones para utilizar cada uno de los algoritmos. Para el algoritmo trust-region-reflective, no se puede subdeterminar el sistema de ecuaciones no lineales; es decir, el número de ecuaciones (el número de elementos de F devuelto por fun) debe ser, al menos, el mismo que la longitud de x. Para obtener más información sobre cómo elegir el algoritmo, consulte Seleccionar el algoritmo.

CheckGradients

Compare las derivadas proporcionadas por el usuario (gradientes de objetivo o de restricciones) con las derivadas de diferencias finitas. Las opciones son false (predeterminada) o true.

Para optimset, el nombre es DerivativeCheck y los valores son 'on' u 'off'. Consulte Nombres de opciones actuales y antiguos.

Diagnóstico

Muestre información de diagnóstico sobre la función que se desea minimizar o resolver. Las opciones son 'off' (predeterminada) o 'on'.

DiffMaxChange

Cambio máximo en variables para gradientes de diferencias finitas (un escalar positivo). La opción predeterminada es Inf.

DiffMinChange

Cambio mínimo en variables para gradientes de diferencias finitas (un escalar positivo). La opción predeterminada es 0.

Display

Nivel de visualización (consulte Iterative Display):

  • 'off' o 'none' no muestran salida alguna.

  • 'iter' muestra la salida en cada iteración y emite el mensaje de salida predeterminado.

  • 'iter-detailed' muestra la salida en cada iteración y emite el mensaje de salida técnico.

  • 'final' (opción predeterminada) solo muestra la salida final y emite el mensaje de salida predeterminado.

  • 'final-detailed' solo muestra la salida final y emite el mensaje de salida técnico.

FiniteDifferenceStepSize

Factor de tamaño de salto de escalar o vector para diferencias finitas. Cuando establece FiniteDifferenceStepSize en un vector v, las diferencias finitas progresivas delta son

delta = v.*sign′(x).*max(abs(x),TypicalX);

, donde sign′(x) = sign(x) excepto sign′(0) = 1. Las diferencias finitas centrales son

delta = v.*max(abs(x),TypicalX);

El escalar FiniteDifferenceStepSize se expande a un vector. La opción predeterminada es sqrt(eps) para diferencias finitas progresivas y eps^(1/3) para diferencias finitas centrales.

Para optimset, el nombre es FinDiffRelStep. Consulte Nombres de opciones actuales y antiguos.

FiniteDifferenceType

Las diferencias finitas, utilizadas para estimar gradientes, son o bien 'forward' (opción predeterminada), o bien 'central' (centradas). La opción 'central' requiere el doble de evaluaciones de función, pero debería ser más precisa.

El algoritmo respeta escrupulosamente los límites cuando estima ambos tipos de diferencias finitas. De este modo, por ejemplo, podrá seleccionar una diferencia regresiva en lugar de progresiva para evitar realizar la evaluación en un punto fuera de los límites.

Para optimset, el nombre es FinDiffType. Consulte Nombres de opciones actuales y antiguos.

FunctionTolerance

Tolerancia de terminación en el valor de la función, un escalar positivo. La opción predeterminada es 1e-6. Consulte Tolerancias y criterios de detención.

Para optimset, el nombre es TolFun. Consulte Nombres de opciones actuales y antiguos.

FunValCheck

Compruebe si los valores de la función son válidos. 'on' muestra un error cuando la función devuelve un valor complex, Inf o NaN. La opción predeterminada 'off' no muestra ningún error.

MaxFunctionEvaluations

Número máximo de evaluaciones de función permitidas, un entero positivo. El valor predeterminado es 100*numberOfVariables para el algoritmo 'trust-region-reflective' y 200*numberOfVariables para el algoritmo 'levenberg-marquardt'. Consulte Tolerancias y criterios de detención y Iteraciones y recuentos de la función.

Para optimset, el nombre es MaxFunEvals. Consulte Nombres de opciones actuales y antiguos.

MaxIterations

Número máximo de iteraciones permitidas, un entero positivo. La opción predeterminada es 400. Consulte Tolerancias y criterios de detención y Iteraciones y recuentos de la función.

Para optimset, el nombre es MaxIter. Consulte Nombres de opciones actuales y antiguos.

OptimalityTolerance

Tolerancia de terminación en la optimalidad de primer orden (un escalar positivo). La opción predeterminada es 1e-6. Consulte Medida de optimalidad de primer orden.

Internamente, el algoritmo 'levenberg-marquardt' utiliza una tolerancia de optimalidad (criterio de detención) de 1e-4 por la FunctionTolerance y no utiliza OptimalityTolerance.

Para optimset, el nombre es TolFun. Consulte Nombres de opciones actuales y antiguos.

OutputFcn

Especifique una o varias funciones definidas por el usuario a las que una función de optimización llame en cada iteración. Pase un identificador de función o un arreglo de celdas de identificadores de función. La opción predeterminada es ninguno ([]). Consulte Output Function and Plot Function Syntax.

PlotFcn

Representa varias medidas de progreso mientras el algoritmo se ejecuta; seleccione una de las gráficas predefinidas o escriba la suya propia. Pase un nombre, un identificador de función o un arreglo de celdas de nombres o identificadores de función. Para funciones de gráfica personalizadas, pase identificadores de función. La opción predeterminada es ninguno ([]):

  • 'optimplotx' representa el punto actual.

  • 'optimplotfunccount' representa el recuento de la función.

  • 'optimplotfval' representa el valor de la función.

  • 'optimplotresnorm' representa la norma de los valores residuales.

  • 'optimplotstepsize' representa el tamaño de salto.

  • 'optimplotfirstorderopt' representa la medida de optimalidad de primer orden.

Las funciones de gráfica personalizadas utilizan la misma sintaxis que las funciones de salida. Consulte Output Functions for Optimization Toolbox y Output Function and Plot Function Syntax.

Para optimset, el nombre es PlotFcns. Consulte Nombres de opciones actuales y antiguos.

SpecifyObjectiveGradient

Si false (opción predeterminada), el solver aproxima la matriz jacobiana utilizando diferencias finitas. Si true, el solver utiliza una matriz jacobiana definida por el usuario (definida en fun) o información jacobiana (cuando se utiliza JacobMult) para la función objetivo.

Para optimset, el nombre es Jacobian y los valores son 'on' u 'off'. Consulte Nombres de opciones actuales y antiguos.

StepTolerance

Tolerancia de terminación en x, un escalar positivo. La opción predeterminada es 1e-6. Consulte Tolerancias y criterios de detención.

Para optimset, el nombre es TolX. Consulte Nombres de opciones actuales y antiguos.

TypicalX

Valores x típicos. El número de elementos en TypicalX es igual al número de elementos en x0, el punto de inicio. El valor predeterminado es ones(numberofvariables,1). El solver utiliza TypicalX para escalar diferencias finitas para la estimación de gradientes.

UseParallel

Cuando true, el solver estima gradientes en paralelo. Deshabilite la opción estableciéndola en la opción predeterminada, false. Consulte Computación paralela.

Algoritmo trust-region-reflective
JacobianMultiplyFcn

Función de multiplicación de matriz jacobiana, especificada como un identificador de función. Para problemas estructurados a gran escala, esta función calcula el producto de la matriz jacobiana J*Y, J'*Y o J'*(J*Y) sin formar J. La función tiene el formato

W = jmfun(Jinfo,Y,flag) 

donde Jinfo contiene la matriz utilizada para calcular J*Y (o J'*Y, o J'*(J*Y)). El primer argumento Jinfo debe ser el mismo que el segundo argumento devuelto por la función objetivo fun, por ejemplo, por

[F,Jinfo] = fun(x)

Y es una matriz que tiene el mismo número de filas que dimensiones hay en el problema. flag determina qué producto se calcula:

  • Si flag == 0, entonces W = J'*(J*Y).

  • Si flag > 0, entonces W = J*Y.

  • Si flag < 0, entonces W = J'*Y.

En cada caso, J no se forma explícitamente. El solver utiliza Jinfo para calcular el precondicionador. Consulte Pasar parámetros adicionales para obtener información sobre cómo proporcionar valores para cualquier parámetro adicional que jmfun necesite.

Nota

'SpecifyObjectiveGradient' debe establecerse en true para que el solver pase Jinfo de fun a jmfun.

Consulte Minimization with Dense Structured Hessian, Linear Equalities y Jacobian Multiply Function with Linear Least Squares para ver ejemplos similares.

Para optimset, el nombre es JacobMult. Consulte Nombres de opciones actuales y antiguos.

JacobPattern

Patrón de dispersión de la matriz jacobiana para diferenciación finita. Establezca JacobPattern(i,j) = 1 cuando fun(i) dependa de x(j). De lo contrario, establezca JacobPattern(i,j) = 0. En otras palabras, establezca JacobPattern(i,j) = 1 cuando puede tener ∂fun(i)/∂x(j) ≠ 0.

Utilice JacobPattern cuando no sea conveniente calcular la matriz jacobiana J en fun, aunque puede determinar (por ejemplo, inspeccionándolo) cuándo fun(i) depende de x(j). El solver puede aproximar J mediante diferencias finitas dispersas cuando proporciona JacobPattern.

Si la estructura es desconocida, no establezca JacobPattern. El comportamiento predeterminado es como si JacobPattern fuera una matriz densa de unos. Entonces, el solver calcula una aproximación completa de diferencias finitas en cada iteración. Esto puede ser costoso para problemas grandes, por lo que normalmente es mejor determinar la estructura de dispersión.

MaxPCGIter

Número máximo de iteraciones PCG (gradiente conjugado precondicionado), un escalar positivo. La opción predeterminada es max(1,numberOfVariables/2). Para obtener más información, consulte Large Scale Nonlinear Least Squares.

PrecondBandWidth

Ancho de banda superior del precondicionador para PCG, un entero no negativo. La opción predeterminada de PrecondBandWidth es Inf, lo que implica que se utiliza una factorización directa (Cholesky) en lugar de los gradientes conjugados (CG). La factorización directa es más costosa computacionalmente que CG, pero produce un salto de mejor calidad hacia la solución. Establezca PrecondBandWidth en 0 para precondicionamiento diagonal (ancho de banda superior de 0). Para algunos problemas, un ancho de banda intermedio reduce el número de iteraciones PCG.

SubproblemAlgorithm

Determina cómo se calcula el salto de iteración. La opción predeterminada, 'factorization', realiza un salto más lento, pero más preciso que 'cg'. Consulte Trust-Region-Reflective Least Squares.

TolPCG

Tolerancia de terminación en la iteración PCG, un escalar positivo. La opción predeterminada es 0.1.

Algoritmo Levenberg-Marquardt
InitDamping

Valor inicial del parámetro de Levenberg-Marquardt, un escalar positivo. La opción predeterminada es 1e-2. Para obtener más detalles, consulte Levenberg-Marquardt Method.

ScaleProblem

'jacobian' puede, en ocasiones, mejorar la convergencia de un problema que no esté bien escalado; la opción predeterminada es 'none'.

Ejemplo: options = optimoptions('lsqnonlin','FiniteDifferenceType','central')

Estructura de problema, especificada como una estructura con los siguientes campos:

Nombre de campoEntrada

objective

Función objetivo

x0

Punto inicial para x
lbVector de límites inferiores
ubVector de límites superiores

solver

'lsqnonlin'

options

Opciones creadas con optimoptions

Debe proporcionar al menos los campos objective, x0, solver y options en la estructura problem.

Tipos de datos: struct

Argumentos de salida

contraer todo

Solución, devuelta como un vector real o un arreglo real. El tamaño de x es el mismo que el tamaño de x0. Habitualmente, x es una solución local al problema cuando exitflag es positivo. Para obtener información sobre la calidad de la solución, consulte Cuando el solver tiene éxito.

Norma cuadrada del valor residual, devuelta como un valor real no negativo. resnorm es la norma euclídea al cuadrado del valor residual en x: sum(fun(x).^2).

Valor de la función objetivo en la solución, devuelto como un arreglo. En general, residual = fun(x).

Razón por la que el solver se ha detenido, devuelta como un entero.

1

La función ha convergido a una solución x.

2

El cambio en x es menor que la tolerancia especificada o la matriz jacobiana en x no está definida.

3

El cambio en el valor residual es menor que la tolerancia especificada.

4

La magnitud relativa de la dirección de búsqueda es menor que la tolerancia de salto.

0

El número de iteraciones sobrepasa options.MaxIterations o el número de evaluaciones de función ha sobrepasado options.MaxFunctionEvaluations.

-1

Una función de gráfica o una función de salida ha detenido el solver.

-2

El problema no es factible: los límites lb y ub son inconsistentes.

Información sobre el proceso de optimización, devuelta como estructura con campos:

firstorderopt

Medida de optimalidad de primer orden

iterations

Número de iteraciones realizadas

funcCount

Número de evaluaciones de función

cgiterations

Número total de iteraciones PCG (solo algoritmo trust-region-reflective)

stepsize

Desplazamiento final en x

algorithm

Algoritmo de optimización utilizado

message

Mensaje de salida

Multiplicadores de Lagrange en la solución, devueltos como una estructura con campos:

lower

Límites inferiores lb

upper

Límites superiores ub

Matriz jacobiana en la solución, devuelta como una matriz real. jacobian(i,j) es la derivada parcial de fun(i) con respecto a x(j) en la solución x.

Limitaciones

  • El algoritmo trust-region-reflective no resuelve sistemas subdeterminados; requiere que el número de ecuaciones, es decir, la dimensión de fila de F, sea al menos igual que el número de variables. En el caso subdeterminado, lsqnonlin utiliza el algoritmo Levenberg-Marquardt.

  • lsqnonlin puede resolver problemas de valores complejos de forma directa. Tenga en cuenta que los límites de restricción no tienen sentido para valores complejos. Para un problema complejo con límites de restricción, divida las variables en partes reales e imaginarias. Consulte Fit a Model to Complex-Valued Data.

  • El cálculo de precondicionador utilizado en la parte del gradiente conjugado precondicionado del método trust-region-reflective forma JTJ (donde J es la matriz jacobiana) antes de calcular el precondicionador. Por lo tanto, una fila de J con muchos elementos distintos de cero, que resulta en un producto JTJ casi denso, puede traducirse en un proceso de resolución costoso para problemas grandes.

  • Si los componentes de x no tienen límites superiores (o inferiores), lsqnonlin prefiere que los correspondientes componentes de ub (o lb) se establezcan en inf (o -inf para límites inferiores) en lugar de un número positivo arbitrario, pero muy grande (o negativo para límites inferiores).

Puede utilizar el algoritmo trust-region reflective en lsqnonlin, lsqcurvefit y fsolve con problemas a pequeña o mediana escala sin calcular la matriz jacobiana en fun o sin proporcionar el patrón de dispersión de la matriz jacobiana. (Esto también se aplica al uso de fmincon o fminunc sin calcular la matriz Hessiana o sin proporcionar el patrón de dispersión de la matriz hessiana). ¿Cómo de pequeña es la escala pequeña o mediana? No existe ninguna respuesta absoluta, ya que depende de la cantidad de memoria virtual en la configuración que haya disponible en sistema del ordenador.

Suponga que su problema tiene m ecuaciones y n incógnitas. Si el comando J = sparse(ones(m,n)) provoca un error Out of memory en su equipo, se trata claramente de un problema demasiado grande. Si no provoca un error, es posible que el problema aún sea demasiado grande. Solo puede saberlo ejecutándolo y comprobando si MATLAB se ejecuta dentro de la cantidad de memoria virtual disponible en el sistema.

Algoritmos

Los métodos Levenberg-Marquardt y trust-region-reflective se basan en los algoritmos de mínimos cuadrados no lineales que también se utilizan en fsolve.

  • Este algoritmo trust-region-reflective predeterminado es un método de región de confianza de subespacio y se basa en el método de Newton de reflejo de punto interior descrito en [1] y [2]. Cada iteración implica la solución aproximada de un sistema lineal amplio utilizando el método de gradientes conjugados precondicionados (PCG). Consulte Trust-Region-Reflective Least Squares.

  • El método de Levenberg-Marquardt se describe en las referencias [4], [5] y [6]. Consulte Levenberg-Marquardt Method.

Funcionalidad alternativa

App

La tarea Optimize de Live Editor proporciona una interfaz visual para lsqnonlin.

Referencias

[1] Coleman, T.F. and Y. Li. “An Interior, Trust Region Approach for Nonlinear Minimization Subject to Bounds.” SIAM Journal on Optimization, Vol. 6, 1996, pp. 418–445.

[2] Coleman, T.F. and Y. Li. “On the Convergence of Reflective Newton Methods for Large-Scale Nonlinear Minimization Subject to Bounds.” Mathematical Programming, Vol. 67, Number 2, 1994, pp. 189–224.

[3] Dennis, J. E. Jr. “Nonlinear Least-Squares.” State of the Art in Numerical Analysis, ed. D. Jacobs, Academic Press, pp. 269–312.

[4] Levenberg, K. “A Method for the Solution of Certain Problems in Least-Squares.” Quarterly Applied Mathematics 2, 1944, pp. 164–168.

[5] Marquardt, D. “An Algorithm for Least-squares Estimation of Nonlinear Parameters.” SIAM Journal Applied Mathematics, Vol. 11, 1963, pp. 431–441.

[6] Moré, J. J. “The Levenberg-Marquardt Algorithm: Implementation and Theory.” Numerical Analysis, ed. G. A. Watson, Lecture Notes in Mathematics 630, Springer Verlag, 1977, pp. 105–116.

[7] Moré, J. J., B. S. Garbow, and K. E. Hillstrom. User Guide for MINPACK 1. Argonne National Laboratory, Rept. ANL–80–74, 1980.

[8] Powell, M. J. D. “A Fortran Subroutine for Solving Systems of Nonlinear Algebraic Equations.” Numerical Methods for Nonlinear Algebraic Equations, P. Rabinowitz, ed., Ch.7, 1970.

Capacidades ampliadas

Historial de versiones

Introducido antes de R2006a