Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

loss

Clase: RegressionLinear

La pérdida de regresión para modelos de regresión lineal

Descripción

ejemplo

L = loss(Mdl,X,Y) Devuelve el error medio cuadrado (MSE) para el modelo de regresión lineal utilizando los Datos predictores y las respuestas correspondientes. contiene un MSE para cada fuerza de regularización en.MdlXYLMdl

ejemplo

L = loss(___,Name,Value) utiliza cualquiera de las sintaxis anteriores y opciones adicionales especificadas por uno o más argumentos de par.Name,Value Por ejemplo, especifique que las columnas de los Datos predictores corresponden a observaciones o especifique la función de pérdida de regresión.

Argumentos de entrada

expandir todo

Modelo de regresión lineal, especificado como un objeto de modelo.RegressionLinear Puede crear un objeto de modelo utilizando.RegressionLinearfitrlinear

Datos de predictor, especificados como una matriz dispersa o por completo.np Esta orientación indica que las filas corresponden a observaciones individuales y las columnas corresponden a variables predictoras individuales.X

Nota

Si orienta la matriz predictora para que las observaciones se correspondan con las columnas y las especifique, puede experimentar una reducción significativa en el tiempo de cálculo.'ObservationsIn','columns'

La longitud y el número de observaciones deben ser iguales.YX

Tipos de datos: single | double

Datos de respuesta, especificados como vector numérico dimensional.n La longitud y el número de observaciones deben ser iguales.YX

Tipos de datos: single | double

Argumentos de par nombre-valor

Especifique pares de argumentos separados por comas opcionales. es el nombre del argumento y es el valor correspondiente. deben aparecer dentro de las cotizaciones.Name,ValueNameValueName Puede especificar varios argumentos de par de nombre y valor en cualquier orden como.Name1,Value1,...,NameN,ValueN

Función de pérdida, especificada como el par separado por comas que consta de un nombre de función de pérdida incorporada o un identificador de función.'LossFun'

  • La tabla siguiente enumera las funciones de pérdida disponibles. Especifique uno utilizando su valor correspondiente. Además, en la tabla, f(x)=xβ+b.

    • es un vector de coeficientes.βp

    • es una observación de variables predictoras.xp

    • es el sesgo escalar.b

    ValorDescripción
    'epsiloninsensitive'Pérdida insensible a épsilon: [y,f(x)]=max[0,|yf(x)|ε]
    'mse'Mse: [y,f(x)]=[yf(x)]2

    es adecuado solo para los alumnos de SVM.'epsiloninsensitive'

  • Especifique su propia función utilizando la notación de identificador de función.

    Vamos a ser el número de observaciones en.nX La función debe tener esta firma

    lossvalue = lossfun(Y,Yhat,W)
    Dónde:

    • El argumento de salida es un escalar.lossvalue

    • Elija el nombre de la función (lossfun).

    • es un vector dimensional de las respuestas observadas.Yn loss pasa el argumento de entrada para.YY

    • es un vector dimensional de las respuestas pronosticadas, que es similar a la salida de.YhatnPredecir

    • es un vector numérico de pesos de observación de-por-1.Wn

    Especifique la función mediante 'LossFun',@lossfun.

Tipos de datos: char | string | function_handle

Dimensión de observación de Datos predictores, especificada como el par separado por comas que consta de y o.'ObservationsIn''columns''rows'

Nota

Si orienta la matriz predictora para que las observaciones se correspondan con las columnas y las especifique, puede experimentar una reducción significativa en el tiempo de ejecución de la optimización.'ObservationsIn','columns'

Ponderaciones de observación, especificadas como el par separado por comas que consta de un vector numérico de valores positivos.'Weights' Si proporciona pesos, calcula la pérdida de clasificación ponderada.loss

Dejar n ser el número de observaciones en.X

  • debe sernumel(Weights) n.

  • De forma predeterminada, esWeights ones(n,1).

Tipos de datos: double | single

Argumentos de salida

expandir todo

Pérdidas de regresión, devueltas como un vector de fila o escalar numérico. La interpretación de depende y.LWeightsLossFun

es del mismo tamaño que.LMdl.Lambda L(j) es la pérdida de regresión del modelo de regresión lineal entrenado utilizando la fuerza de regularización Mdl.Lambda(j).

Nota

Si es, después el término de la pérdida en la función objetiva es la mitad del MSE. vuelve el MSE por abandono.Mdl.FittedLoss'mse'loss Por lo tanto, si usted utiliza para marcar el error de reenvío (entrenamiento), después hay una discrepancia entre el MSE y los resultados de la optimización que vuelven.lossfitrlinear

Ejemplos

expandir todo

Simular 10000 observaciones de este modelo

<math display="block">
<mrow>
<mi>y</mi>
<mo>=</mo>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
<mn>0</mn>
<mn>0</mn>
</mrow>
</msub>
<mo>+</mo>
<mn>2</mn>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
<mn>0</mn>
<mn>0</mn>
</mrow>
</msub>
<mo>+</mo>
<mi>e</mi>
<mo>.</mo>
</mrow>
</math>

  • <math display="block">
    <mrow>
    <mi>X</mi>
    <mo>=</mo>
    <mrow>
    <msub>
    <mrow>
    <mi>x</mi>
    </mrow>
    <mrow>
    <mn>1</mn>
    </mrow>
    </msub>
    <mo>,</mo>
    <mo>.</mo>
    <mo>.</mo>
    <mo>.</mo>
    <mo>,</mo>
    <msub>
    <mrow>
    <mi>x</mi>
    </mrow>
    <mrow>
    <mn>1</mn>
    <mn>0</mn>
    <mn>0</mn>
    <mn>0</mn>
    </mrow>
    </msub>
    </mrow>
    </mrow>
    </math>
    es una matriz dispersa 10000-by-1000 con un 10% de cero elementos normales estándar.

  • es un error normal aleatorio con la media 0 y la desviación estándar 0,3.e

rng(1) % For reproducibility n = 1e4; d = 1e3; nz = 0.1; X = sprandn(n,d,nz); Y = X(:,100) + 2*X(:,200) + 0.3*randn(n,1);

Entrenar un modelo de regresión lineal. Reserve el 30% de las observaciones como una muestra de exclusión.

CVMdl = fitrlinear(X,Y,'Holdout',0.3); Mdl = CVMdl.Trained{1}
Mdl =    RegressionLinear          ResponseName: 'Y'     ResponseTransform: 'none'                  Beta: [1000x1 double]                  Bias: -0.0066                Lambda: 1.4286e-04               Learner: 'svm'     Properties, Methods  

es un modelo.CVMdlRegressionPartitionedLinear Contiene la propiedad, que es un array de celdas 1-por-1 sosteniendo un modelo que el software entrenado usando el conjunto de entrenamiento.TrainedRegressionLinear

Extraiga los datos de entrenamiento y prueba de la definición de partición.

trainIdx = training(CVMdl.Partition); testIdx = test(CVMdl.Partition);

Estime el MSE de la formación-y de la prueba-muestra.

mseTrain = loss(Mdl,X(trainIdx,:),Y(trainIdx))
mseTrain = 0.1496 
mseTest = loss(Mdl,X(testIdx,:),Y(testIdx))
mseTest = 0.1798 

Porque hay una fuerza de regularización en, y son escalares numéricos.MdlmseTrainmseTest

Simular 10000 observaciones de este modelo

<math display="block">
<mrow>
<mi>y</mi>
<mo>=</mo>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
<mn>0</mn>
<mn>0</mn>
</mrow>
</msub>
<mo>+</mo>
<mn>2</mn>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
<mn>0</mn>
<mn>0</mn>
</mrow>
</msub>
<mo>+</mo>
<mi>e</mi>
<mo>.</mo>
</mrow>
</math>

  • <math display="block">
    <mrow>
    <mi>X</mi>
    <mo>=</mo>
    <mrow>
    <msub>
    <mrow>
    <mi>x</mi>
    </mrow>
    <mrow>
    <mn>1</mn>
    </mrow>
    </msub>
    <mo>,</mo>
    <mo>.</mo>
    <mo>.</mo>
    <mo>.</mo>
    <mo>,</mo>
    <msub>
    <mrow>
    <mi>x</mi>
    </mrow>
    <mrow>
    <mn>1</mn>
    <mn>0</mn>
    <mn>0</mn>
    <mn>0</mn>
    </mrow>
    </msub>
    </mrow>
    </mrow>
    </math>
    es una matriz dispersa 10000-by-1000 con un 10% de cero elementos normales estándar.

  • es un error normal aleatorio con la media 0 y la desviación estándar 0,3.e

rng(1) % For reproducibility n = 1e4; d = 1e3; nz = 0.1; X = sprandn(n,d,nz);  Y = X(:,100) + 2*X(:,200) + 0.3*randn(n,1); X = X'; % Put observations in columns for faster training

Entrenar un modelo de regresión lineal. Reserve el 30% de las observaciones como una muestra de exclusión.

CVMdl = fitrlinear(X,Y,'Holdout',0.3,'ObservationsIn','columns');  Mdl = CVMdl.Trained{1}
Mdl =    RegressionLinear          ResponseName: 'Y'     ResponseTransform: 'none'                  Beta: [1000x1 double]                  Bias: -0.0066                Lambda: 1.4286e-04               Learner: 'svm'     Properties, Methods  

es un modelo.CVMdlRegressionPartitionedLinear Contiene la propiedad, que es un array de celdas 1-por-1 sosteniendo un modelo que el software entrenado usando el conjunto de entrenamiento.TrainedRegressionLinear

Extraiga los datos de entrenamiento y prueba de la definición de partición.

trainIdx = training(CVMdl.Partition); testIdx = test(CVMdl.Partition);

Crear una función anónima que mide la pérdida de Huber (

<math display="block">
<mrow>
<mi>δ</mi>
</mrow>
</math>
= 1), es decir,

<math display="block">
<mrow>
<mrow>
<mi>L</mi>
<mo>=</mo>
<mfrac>
<mrow>
<mn>1</mn>
</mrow>
<mrow>
<mrow>
<mo></mo>
<mrow>
<mrow>
<msub>
<mrow>
<mi>w</mi>
</mrow>
<mrow>
<mi>j</mi>
</mrow>
</msub>
</mrow>
</mrow>
</mrow>
</mrow>
</mfrac>
<munderover>
<mrow>
<mo></mo>
</mrow>
<mrow>
<mi>j</mi>
<mo>=</mo>
<mn>1</mn>
</mrow>
<mrow>
<mi>n</mi>
</mrow>
</munderover>
<mrow>
<mrow>
<msub>
<mrow>
<mi>w</mi>
</mrow>
<mrow>
<mi>j</mi>
</mrow>
</msub>
</mrow>
<mrow>
<msub>
<mrow>
<mo></mo>
</mrow>
<mrow>
<mi>j</mi>
</mrow>
</msub>
</mrow>
</mrow>
<mo>,</mo>
</mrow>
</mrow>
</math>

Dónde

<math display="block">
<mrow>
<mtable columnalign="left">
<mtr>
<mtd>
<mrow></mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<msub>
<mrow>
<mo></mo>
</mrow>
<mrow>
<mi>j</mi>
</mrow>
</msub>
</mrow>
<mo>=</mo>
<mrow>
<mo>{</mo>
<mrow>
<mtable columnalign="center center center center center center center center center center center center center center center center center center center center">
<mtr>
<mtd>
<mrow>
<mrow>
<mn>0</mn>
<mo>.</mo>
<mn>5</mn>
<mrow>
<msup>
<mrow>
<munderover accent="true">
<mrow>
<msub>
<mrow>
<mi>e</mi>
</mrow>
<mrow>
<mi>j</mi>
</mrow>
</msub>
</mrow>
<mrow></mrow>
<mrow>
<mo>ˆ</mo>
</mrow>
</munderover>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msup>
<mo>;</mo>
</mrow>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<mo>|</mo>
<mrow>
<munderover accent="true">
<mrow>
<msub>
<mrow>
<mi>e</mi>
</mrow>
<mrow>
<mi>j</mi>
</mrow>
</msub>
</mrow>
<mrow></mrow>
<mrow>
<mo>ˆ</mo>
</mrow>
</munderover>
</mrow>
<mo>|</mo>
</mrow>
<mo>-</mo>
<mn>0</mn>
<mo>.</mo>
<mn>5</mn>
<mo>;</mo>
<mspace width="0.2777777777777778em"></mspace>
<mspace width="0.2777777777777778em"></mspace>
</mrow>
</mrow>
</mtd>
</mtr>
</mtable>
<mtable columnalign="center center center center center center center center center center center center center center center center center center center center">
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow></mrow>
</mrow>
</mstyle>
</mrow>
<mspace width="0.2777777777777778em"></mspace>
<mspace width="0.2777777777777778em"></mspace>
<mrow>
<mrow>
<mo>|</mo>
<mrow>
<munderover accent="true">
<mrow>
<msub>
<mrow>
<mi>e</mi>
</mrow>
<mrow>
<mi>j</mi>
</mrow>
</msub>
</mrow>
<mrow></mrow>
<mrow>
<mo>ˆ</mo>
</mrow>
</munderover>
</mrow>
<mo>|</mo>
</mrow>
</mrow>
<mo></mo>
<mn>1</mn>
</mrow>
</mrow>
</mtd>
</mtr>
<mtr>
<mtd>
<mrow>
<mrow>
<mrow>
<mstyle mathvariant="normal">
<mrow>
<mrow></mrow>
</mrow>
</mstyle>
</mrow>
<mspace width="0.2777777777777778em"></mspace>
<mspace width="0.2777777777777778em"></mspace>
<mrow>
<mrow>
<mo>|</mo>
<mrow>
<munderover accent="true">
<mrow>
<msub>
<mrow>
<mi>e</mi>
</mrow>
<mrow>
<mi>j</mi>
</mrow>
</msub>
</mrow>
<mrow></mrow>
<mrow>
<mo>ˆ</mo>
</mrow>
</munderover>
</mrow>
<mo>|</mo>
</mrow>
</mrow>
<mo>></mo>
<mn>1</mn>
</mrow>
</mrow>
</mtd>
</mtr>
</mtable>
</mrow>
</mrow>
<mo>.</mo>
</mrow>
</mrow>
</mtd>
</mtr>
</mtable>
</mrow>
</math>

<math display="inline">
<mrow>
<munderover accent="true">
<mrow>
<msub>
<mrow>
<mi>e</mi>
</mrow>
<mrow>
<mi>j</mi>
</mrow>
</msub>
</mrow>
<mrow></mrow>
<mrow>
<mo>ˆ</mo>
</mrow>
</munderover>
</mrow>
</math>
es el residuo para la observación.j Las funciones de pérdida personalizadas deben escribirse en un formulario determinado. Para obtener reglas sobre cómo escribir una función de pérdida personalizada, vea el argumento de par nombre-valor.'LossFun'

huberloss = @(Y,Yhat,W)sum(W.*((0.5*(abs(Y-Yhat)<=1).*(Y-Yhat).^2) + ...     ((abs(Y-Yhat)>1).*abs(Y-Yhat)-0.5)))/sum(W);

Estimar el conjunto de entrenamiento y la pérdida de regresión del conjunto de pruebas utilizando la función de pérdida Huber.

eTrain = loss(Mdl,X(:,trainIdx),Y(trainIdx),'LossFun',huberloss,...     'ObservationsIn','columns')
eTrain = -0.4186 
eTest = loss(Mdl,X(:,testIdx),Y(testIdx),'LossFun',huberloss,...     'ObservationsIn','columns')
eTest = -0.4010 

Simular 10000 observaciones de este modelo

<math display="block">
<mrow>
<mi>y</mi>
<mo>=</mo>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>1</mn>
<mn>0</mn>
<mn>0</mn>
</mrow>
</msub>
<mo>+</mo>
<mn>2</mn>
<msub>
<mrow>
<mi>x</mi>
</mrow>
<mrow>
<mn>2</mn>
<mn>0</mn>
<mn>0</mn>
</mrow>
</msub>
<mo>+</mo>
<mi>e</mi>
<mo>.</mo>
</mrow>
</math>

  • <math display="block">
    <mrow>
    <mi>X</mi>
    <mo>=</mo>
    <mo stretchy="false">{</mo>
    <msub>
    <mrow>
    <mi>x</mi>
    </mrow>
    <mrow>
    <mn>1</mn>
    </mrow>
    </msub>
    <mo>,</mo>
    <mo>.</mo>
    <mo>.</mo>
    <mo>.</mo>
    <mo>,</mo>
    <msub>
    <mrow>
    <mi>x</mi>
    </mrow>
    <mrow>
    <mn>1</mn>
    <mn>0</mn>
    <mn>0</mn>
    <mn>0</mn>
    </mrow>
    </msub>
    <mo stretchy="false">}</mo>
    </mrow>
    </math>
    es una matriz dispersa 10000-by-1000 con un 10% de cero elementos normales estándar.

  • es un error normal aleatorio con la media 0 y la desviación estándar 0,3.e

rng(1) % For reproducibility n = 1e4; d = 1e3; nz = 0.1; X = sprandn(n,d,nz); Y = X(:,100) + 2*X(:,200) + 0.3*randn(n,1);

Cree un conjunto de 15 puntos fuertes de regularización logarmicamente espaciados de

<math display="block">
<mrow>
<mn>1</mn>
<msup>
<mrow>
<mn>0</mn>
</mrow>
<mrow>
<mo>-</mo>
<mn>4</mn>
</mrow>
</msup>
</mrow>
</math>
a través de
<math display="block">
<mrow>
<mn>1</mn>
<msup>
<mrow>
<mn>0</mn>
</mrow>
<mrow>
<mo>-</mo>
<mn>1</mn>
</mrow>
</msup>
</mrow>
</math>
.

Lambda = logspace(-4,-1,15);

Mantenga el 30% de los datos para las pruebas. Identifique los índices de muestreo de prueba.

cvp = cvpartition(numel(Y),'Holdout',0.30); idxTest = test(cvp);

Entrenar un modelo de regresión lineal utilizando las sanciones de lazo con las fortalezas en.Lambda Especifique las fortalezas de regularización, optimizando la función objetiva utilizando SpaRSA y la partición de datos. Para aumentar la velocidad de ejecución, transponer los Datos predictores y especificar que las observaciones se encuentran en columnas.

X = X';  CVMdl = fitrlinear(X,Y,'ObservationsIn','columns','Lambda',Lambda,...     'Solver','sparsa','Regularization','lasso','CVPartition',cvp); Mdl1 = CVMdl.Trained{1}; numel(Mdl1.Lambda)
ans = 15 

es un modelo.Mdl1RegressionLinear Debido a que es un vector de 15 dimensiones de las fortalezas de regularización, se puede pensar en como 15 modelos entrenados, uno para cada fuerza de regularización.LambdaMdl1

Calcule el error cuadrado medio de la muestra de prueba para cada modelo regularizado.

mse = loss(Mdl1,X(:,idxTest),Y(idxTest),'ObservationsIn','columns');

Valores más altos de plomo a la dispersión variable predictora, que es una buena calidad de un modelo de regresión.Lambda Vuelva a entrenar el modelo utilizando todo el conjunto de datos y todas las opciones utilizadas anteriormente, excepto la especificación de partición de datos. Determine el número de coeficientes distintos de cero por modelo.

Mdl = fitrlinear(X,Y,'ObservationsIn','columns','Lambda',Lambda,...     'Solver','sparsa','Regularization','lasso'); numNZCoeff = sum(Mdl.Beta~=0);

En la misma figura, trace el MSE y la frecuencia de los coeficientes distintos de cero para cada fuerza de regularización. Trace todas las variables en la escala de registro.

figure; [h,hL1,hL2] = plotyy(log10(Lambda),log10(mse),...     log10(Lambda),log10(numNZCoeff));  hL1.Marker = 'o'; hL2.Marker = 'o'; ylabel(h(1),'log_{10} MSE') ylabel(h(2),'log_{10} nonzero-coefficient frequency') xlabel('log_{10} Lambda') hold off

Seleccione el índice o los índices de ese equilibrio de error de clasificación mínima y la dispersión variable predictora (por ejemplo,).LambdaLambda(11)

idx = 11; MdlFinal = selectModels(Mdl,idx);

es un objeto de modelo entrenado que utiliza como fuerza de regularización.MdlFinalRegressionLinearLambda(11)

Capacidades ampliadas

Consulte también

| |

Introducido en R2016a