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.

fitrkernel

Ajuste el modelo de regresión del kernel gaussiano utilizando la expansión de características aleatorias

Descripción

entrena o realiza una validación cruzada de un modelo de regresión del kernel gaussiano para la regresión no lineal. es más práctico de usar para aplicaciones de macrodatos que tienen grandes conjuntos de entrenamiento, pero también se pueden aplicar a conjuntos de datos más pequeños que caben en la memoria.fitrkernelfitrkernel

asigna datos en un espacio de dimensiones reducidas a un espacio de alta dimensionalidad y, a continuación, se ajusta a un modelo lineal en el espacio de alta dimensión minimizando la función objetiva regularizada.fitrkernel La obtención del modelo lineal en el espacio de alta dimensionalidad equivale a aplicar el kernel gaussiano al modelo en el espacio de dimensiones reducidas. Los modelos de regresión lineal disponibles incluyen modelos de regresión de máquina vectorial de soporte regularizado (SVM) y de mínimos cuadrados.

Para entrenar un modelo de regresión SVM no lineal en datos en memoria, consulte.fitrsvm

ejemplo

Mdl = fitrkernel(X,Y) Devuelve un modelo de regresión de kernel gaussiano compacto entrenado utilizando los datos del predictor y las respuestas correspondientes.XY

ejemplo

Mdl = fitrkernel(X,Y,Name,Value) Devuelve un modelo de regresión del kernel con opciones adicionales especificadas por uno o más argumentos de par nombre-valor. Por ejemplo, puede implementar la regresión de mínimos cuadrados, especificar el número de dimensiones del espacio expandido o especificar opciones de validación cruzada.

ejemplo

[Mdl,FitInfo] = fitrkernel(___) también devuelve la información de ajuste en la matriz de estructura utilizando cualquiera de los argumentos de entrada en las sintaxis anteriores.FitInfo No puede solicitar modelos con validación cruzada.FitInfo

ejemplo

[Mdl,FitInfo,HyperparameterOptimizationResults] = fitrkernel(___) también devuelve los resultados de la optimización de hiperparámetros cuando se optimizan los hiperparámetros mediante el argumento de par nombre-valor.'OptimizeHyperparameters'

Ejemplos

contraer todo

Entrenar un modelo de regresión de kernel para una matriz alta mediante SVM.

Cree un almacén de datos que hace referencia a la ubicación de la carpeta con los datos. Los datos pueden estar contenidos en un único archivo, una colección de archivos o una carpeta completa. Trate los valores como datos faltantes para que los Reemplace con valores.'NA'datastoreNaN Seleccione un subconjunto de las variables que desee utilizar. Cree una tabla alta en la parte superior del almacén de datos.

varnames = {'ArrTime','DepTime','ActualElapsedTime'}; ds = datastore('airlinesmall.csv','TreatAsMissing','NA',...     'SelectedVariableNames',varnames); t = tall(ds);

Especifique y como las variables predictoras () y como variable de respuesta ().DepTimeArrTimeXActualElapsedTimeY Seleccione las observaciones para las que es posterior.ArrTimeDepTime

daytime = t.ArrTime>t.DepTime; Y = t.ActualElapsedTime(daytime);     % Response data X = t{daytime,{'DepTime' 'ArrTime'}}; % Predictor data

Estandarizar las variables predictoras.

Z = zscore(X); % Standardize the data

Entrenar un modelo de regresión de kernel gaussiano predeterminado con los predictores estandarizados. Extraiga un resumen de ajuste para determinar qué tan bien se ajusta el algoritmo de optimización al modelo a los datos.

[Mdl,FitInfo] = fitrkernel(Z,Y)
Found 6 chunks. |========================================================================= | Solver | Iteration  /  |   Objective   |   Gradient    | Beta relative | |        | Data Pass     |               |   magnitude   |    change     | |========================================================================= |   INIT |     0 /     1 |  4.335200e+01 |  9.821993e-02 |           NaN | |  LBFGS |     0 /     2 |  3.693870e+01 |  1.566041e-02 |  9.988238e-01 | |  LBFGS |     1 /     3 |  3.692143e+01 |  3.030550e-02 |  1.352488e-03 | |  LBFGS |     2 /     4 |  3.689521e+01 |  2.919252e-02 |  1.137336e-03 | |  LBFGS |     2 /     5 |  3.686922e+01 |  2.801905e-02 |  2.277224e-03 | |  LBFGS |     2 /     6 |  3.681793e+01 |  2.615365e-02 |  4.564688e-03 | |  LBFGS |     2 /     7 |  3.671782e+01 |  2.276596e-02 |  9.170612e-03 | |  LBFGS |     2 /     8 |  3.652813e+01 |  1.868733e-02 |  1.850839e-02 | |  LBFGS |     3 /     9 |  3.442961e+01 |  3.260732e-02 |  2.030226e-01 | |  LBFGS |     4 /    10 |  3.473328e+01 |  8.506865e-02 |  3.309396e-01 | |  LBFGS |     4 /    11 |  3.378744e+01 |  5.473648e-02 |  1.428247e-01 | |  LBFGS |     5 /    12 |  3.329728e+01 |  3.922448e-02 |  1.026073e-01 | |  LBFGS |     6 /    13 |  3.309615e+01 |  1.551459e-02 |  6.118966e-02 | |  LBFGS |     7 /    14 |  3.300400e+01 |  1.759430e-02 |  1.918912e-02 | |  LBFGS |     8 /    15 |  3.277892e+01 |  3.155320e-02 |  4.781893e-02 | |  LBFGS |     9 /    16 |  3.255352e+01 |  3.435953e-02 |  4.200697e-02 | |  LBFGS |    10 /    17 |  3.207945e+01 |  6.192847e-02 |  2.161540e-01 | |  LBFGS |    11 /    18 |  3.171391e+01 |  3.185452e-02 |  1.204747e-01 | |  LBFGS |    12 /    19 |  3.155433e+01 |  1.183853e-02 |  5.837098e-02 | |  LBFGS |    13 /    20 |  3.149625e+01 |  1.132499e-02 |  2.169556e-02 | |========================================================================= | Solver | Iteration  /  |   Objective   |   Gradient    | Beta relative | |        | Data Pass     |               |   magnitude   |    change     | |========================================================================= |  LBFGS |    14 /    21 |  3.136724e+01 |  1.478355e-02 |  3.132871e-02 | |  LBFGS |    15 /    22 |  3.115575e+01 |  1.461357e-02 |  7.221907e-02 | |  LBFGS |    16 /    23 |  3.091292e+01 |  1.900119e-02 |  1.237602e-01 | |  LBFGS |    17 /    24 |  3.076649e+01 |  3.469328e-02 |  1.664433e-01 | |  LBFGS |    18 /    25 |  3.104221e+01 |  1.341798e-01 |  2.831585e-02 | |  LBFGS |    18 /    26 |  3.076703e+01 |  4.929652e-02 |  1.414956e-02 | |  LBFGS |    18 /    27 |  3.073332e+01 |  1.434614e-02 |  7.072158e-03 | |  LBFGS |    19 /    28 |  3.067248e+01 |  9.931353e-03 |  2.438284e-02 | |  LBFGS |    20 /    29 |  3.063153e+01 |  6.781994e-03 |  1.606731e-02 | |========================================================================| 
Mdl =    RegressionKernel             PredictorNames: {'x1'  'x2'}               ResponseName: 'Y'                    Learner: 'svm'     NumExpansionDimensions: 64                KernelScale: 1                     Lambda: 8.5385e-06              BoxConstraint: 1                    Epsilon: 5.9303     Properties, Methods  
FitInfo = struct with fields:
                  Solver: 'LBFGS-tall'
            LossFunction: 'epsiloninsensitive'
                  Lambda: 8.5385e-06
           BetaTolerance: 1.0000e-03
       GradientTolerance: 1.0000e-05
          ObjectiveValue: 30.6315
       GradientMagnitude: 0.0068
    RelativeChangeInBeta: 0.0161
                 FitTime: 77.1910
                 History: [1×1 struct]

es un modelo.MdlRegressionKernel Para inspeccionar el error de regresión, puede pasar y los datos de entrenamiento o nuevos datos a la función.Mdlloss O puede pasar y nuevos Datos predictores a la función para predecir las respuestas de las nuevas observaciones.Mdlpredict También puede pasar y los datos de entrenamiento a la función para continuar el entrenamiento.Mdlresume

es una matriz de estructura que contiene información de optimización.FitInfo Utilícese para determinar si las mediciones de terminación de optimización son satisfactorias.FitInfo

Para mejorar la precisión, puede aumentar el número máximo de iteraciones de optimización () y reducir los valores de tolerancia (y) utilizando los argumentos de par nombre-valor de fitrkernel.'IterationLimit''BetaTolerance''GradientTolerance' Hacerlo puede mejorar las medidas como y en.ObjectiveValueRelativeChangeInBetaFitInfo También puede optimizar los parámetros del modelo mediante el argumento de par nombre-valor.'OptimizeHyperparameters'

Cargue el conjunto de datos.carbig

load carbig

Especifique las variables predictoras () y la variable de respuesta ().XY

X = [Acceleration,Cylinders,Displacement,Horsepower,Weight]; Y = MPG;

Eliminar filas de y donde cualquiera de las matrices tiene valores.XYNaN La eliminación de filas con valores antes de pasar datos puede acelerar el entrenamiento y reducir el uso de memoria.NaNfitrkernel

R = rmmissing([X Y]); % Data with missing entries removed X = R(:,1:5);  Y = R(:,end); 

Estandarizar las variables predictoras.

Z = zscore(X);

Valide de forma cruzada un modelo de regresión del kernel utilizando la validación cruzada de 5 veces.

Mdl = fitrkernel(Z,Y,'Kfold',5)
Mdl =    classreg.learning.partition.RegressionPartitionedKernel     CrossValidatedModel: 'Kernel'            ResponseName: 'Y'         NumObservations: 392                   KFold: 5               Partition: [1x1 cvpartition]       ResponseTransform: 'none'     Properties, Methods  
numel(Mdl.Trained)
ans = 5 

es un modelo.MdlRegressionPartitionedKernel Debido a que implementa la validación cruzada de cinco veces, contiene cinco modelos que el software entrena en observaciones de plegado (en pliegue) de la formación.fitrkernelMdlRegressionKernel

Examine la pérdida de validación cruzada (error cuadrado medio) para cada pliegue.

kfoldLoss(Mdl,'mode','individual')
ans = 5×1

   13.0610
   14.0975
   24.0104
   21.1223
   24.3979

Optimice los hiperparámetros automáticamente mediante el argumento de par nombre-valor.'OptimizeHyperparameters'

Cargue el conjunto de datos.carbig

load carbig

Especifique las variables predictoras () y la variable de respuesta ().XY

X = [Acceleration,Cylinders,Displacement,Horsepower,Weight]; Y = MPG;

Eliminar filas de y donde cualquiera de las matrices tiene valores.XYNaN La eliminación de filas con valores antes de pasar datos puede acelerar el entrenamiento y reducir el uso de memoria.NaNfitrkernel

R = rmmissing([X Y]); % Data with missing entries removed X = R(:,1:5);  Y = R(:,end); 

Estandarizar las variables predictoras.

Z = zscore(X);

Encuentre hiperparámetros que minimicen la pérdida de validación cruzada de cinco veces mediante la optimización automática de hiperparámetros. Especifíquese de modo que encuentre los valores óptimos de los argumentos de par nombre-valor.'OptimizeHyperparameters''auto'fitrkernel'KernelScale''Lambda''Epsilon' Para reproducibilidad, establezca la semilla aleatoria y utilice la función de adquisición.'expected-improvement-plus'

rng('default') [Mdl,FitInfo,HyperparameterOptimizationResults] = fitrkernel(Z,Y,'OptimizeHyperparameters','auto',...     'HyperparameterOptimizationOptions',struct('AcquisitionFunctionName','expected-improvement-plus'))

|====================================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |  KernelScale |       Lambda |      Epsilon | |      | result |             | runtime     | (observed)  | (estim.)    |              |              |              | |====================================================================================================================| |    1 | Best   |      4.8295 |      7.5385 |      4.8295 |      4.8295 |     0.011518 |   6.8068e-05 |      0.95918 | |    2 | Best   |      4.1488 |     0.54274 |      4.1488 |      4.1855 |       477.57 |     0.066115 |     0.091828 | |    3 | Accept |      4.1521 |     0.36136 |      4.1488 |      4.1747 |    0.0080478 |    0.0052867 |       520.84 | |    4 | Accept |      4.1506 |     0.55096 |      4.1488 |      4.1488 |      0.10935 |      0.35931 |     0.013372 | |    5 | Best   |      4.1446 |      0.6407 |      4.1446 |      4.1446 |       326.29 |       2.5457 |      0.22475 | |    6 | Accept |      4.1521 |     0.30501 |      4.1446 |      4.1447 |       719.11 |      0.19478 |       881.84 | |    7 | Accept |      4.1501 |     0.43756 |      4.1446 |      4.1461 |     0.052426 |       2.5402 |     0.051319 | |    8 | Accept |      4.1521 |     0.39821 |      4.1446 |      4.1447 |       990.71 |     0.014203 |       702.34 | |    9 | Accept |      4.1521 |      0.7237 |      4.1446 |      4.1465 |       415.85 |     0.054602 |       81.005 | |   10 | Accept |      4.1454 |     0.76063 |      4.1446 |      4.1455 |       972.49 |       1.1601 |       1.8715 | |   11 | Accept |      4.1495 |     0.61144 |      4.1446 |      4.1473 |       121.79 |       1.4077 |     0.061055 | |   12 | Accept |      4.1521 |     0.41885 |      4.1446 |      4.1474 |       985.81 |      0.83297 |       213.45 | |   13 | Best   |      4.1374 |     0.58669 |      4.1374 |      4.1441 |       167.34 |       2.5497 |       4.8997 | |   14 | Accept |      4.1434 |     0.29983 |      4.1374 |      4.1437 |       74.527 |         2.55 |       6.1044 | |   15 | Accept |      4.1402 |     0.28464 |      4.1374 |      4.1407 |       877.17 |       2.5391 |       2.2888 | |   16 | Accept |      4.1436 |     0.35069 |      4.1374 |      4.1412 |    0.0010354 |     0.017613 |      0.11811 | |   17 | Best   |      4.1346 |     0.38015 |      4.1346 |      4.1375 |    0.0010362 |     0.010401 |       8.9719 | |   18 | Accept |      4.1521 |     0.25429 |      4.1346 |      4.1422 |    0.0010467 |    0.0094817 |       563.96 | |   19 | Accept |      4.1508 |      0.3722 |      4.1346 |      4.1367 |       760.12 |    0.0079557 |     0.009087 | |   20 | Accept |      4.1435 |     0.74225 |      4.1346 |       4.143 |     0.020647 |    0.0089063 |       2.3699 | |====================================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |  KernelScale |       Lambda |      Epsilon | |      | result |             | runtime     | (observed)  | (estim.)    |              |              |              | |====================================================================================================================| |   21 | Best   |      3.7172 |      1.2313 |      3.7172 |      3.7174 |       818.08 |   2.5529e-06 |       2.1058 | |   22 | Accept |      4.1521 |      0.4137 |      3.7172 |      3.7177 |     0.006272 |   2.5598e-06 |       93.063 | |   23 | Accept |      4.0567 |      1.0034 |      3.7172 |      3.7176 |       940.43 |   2.6941e-06 |      0.12016 | |   24 | Best   |      2.8979 |      7.6196 |      2.8979 |      2.8979 |       37.141 |   2.5677e-06 |         2.71 | |   25 | Accept |      4.1521 |     0.47654 |      2.8979 |       2.898 |       13.817 |   2.5755e-06 |       863.91 | |   26 | Best   |       2.795 |      3.2849 |       2.795 |      2.7953 |       20.022 |   2.6098e-06 |       1.6561 | |   27 | Accept |      2.8284 |      3.8849 |       2.795 |      2.7956 |       17.252 |   2.7719e-06 |      0.82777 | |   28 | Best   |      2.7896 |      1.6324 |      2.7896 |      2.7898 |       11.432 |    7.621e-06 |        2.094 | |   29 | Accept |       2.819 |      2.6041 |      2.7896 |      2.7899 |       8.5133 |   2.5872e-06 |       2.0567 | |   30 | Accept |      2.8061 |      1.2659 |      2.7896 |      2.7968 |       15.823 |   6.1956e-06 |       2.0085 |  __________________________________________________________ Optimization completed. MaxObjectiveEvaluations of 30 reached. Total function evaluations: 30 Total elapsed time: 109.0396 seconds. Total objective function evaluation time: 39.9771  Best observed feasible point:     KernelScale     Lambda      Epsilon     ___________    _________    _______        11.432       7.621e-06     2.094   Observed objective function value = 2.7896 Estimated objective function value = 2.7968 Function evaluation time = 1.6324  Best estimated feasible point (according to models):     KernelScale      Lambda      Epsilon     ___________    __________    _______        15.823       6.1956e-06    2.0085   Estimated objective function value = 2.7968 Estimated function evaluation time = 2.3349 
Mdl =    RegressionKernel               ResponseName: 'Y'                    Learner: 'svm'     NumExpansionDimensions: 256                KernelScale: 15.8229                     Lambda: 6.1956e-06              BoxConstraint: 411.7488                    Epsilon: 2.0085     Properties, Methods  
FitInfo = struct with fields:
                  Solver: 'LBFGS-fast'
            LossFunction: 'epsiloninsensitive'
                  Lambda: 6.1956e-06
           BetaTolerance: 1.0000e-04
       GradientTolerance: 1.0000e-06
          ObjectiveValue: 1.3582
       GradientMagnitude: 0.0051
    RelativeChangeInBeta: 5.3944e-05
                 FitTime: 0.2646
                 History: []

HyperparameterOptimizationResults =    BayesianOptimization with properties:                        ObjectiveFcn: @createObjFcn/inMemoryObjFcn               VariableDescriptions: [5x1 optimizableVariable]                            Options: [1x1 struct]                       MinObjective: 2.7896                    XAtMinObjective: [1x3 table]              MinEstimatedObjective: 2.7968           XAtMinEstimatedObjective: [1x3 table]            NumObjectiveEvaluations: 30                   TotalElapsedTime: 109.0396                          NextPoint: [1x3 table]                             XTrace: [30x3 table]                     ObjectiveTrace: [30x1 double]                   ConstraintsTrace: []                      UserDataTrace: {30x1 cell}       ObjectiveEvaluationTimeTrace: [30x1 double]                 IterationTimeTrace: [30x1 double]                         ErrorTrace: [30x1 double]                   FeasibilityTrace: [30x1 logical]        FeasibilityProbabilityTrace: [30x1 double]                IndexOfMinimumTrace: [30x1 double]              ObjectiveMinimumTrace: [30x1 double]     EstimatedObjectiveMinimumTrace: [30x1 double]  

Para Big Data, el procedimiento de optimización puede tardar mucho tiempo. Si el conjunto de datos es demasiado grande para ejecutar el procedimiento de optimización, puede intentar optimizar los parámetros utilizando solo datos parciales. Utilice la función y especifique los datos de muestra sin reemplazo.datasample'Replace','false'

Argumentos de entrada

contraer todo

Los Datos predictores a los que se ajusta el modelo de regresión, especificados como una matriz numérica, donde es el número de observaciones y es el número de variables predictoras.npnp

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

Nota

fitrkernel elimina las observaciones faltantes, es decir, las observaciones con cualquiera de estas características:

  • elementos de la respuesta ()NaNY

  • Al menos un valor en una observación predictora (fila en)NaNX

  • valor o peso ()NaN0'Weights'

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

Ejemplo: implementa la regresión de mínimos cuadrados después de asignar los Datos predictores al espacio dimensional mediante la expansión de entidades con un parámetro de escala de kernel seleccionado por un procedimiento heurístico.Mdl = fitrkernel(X,Y,'Learner','leastsquares','NumExpansionDimensions',2^15,'KernelScale','auto')2^15

Nota

No puede usar ningún argumento de par nombre-valor de validación cruzada junto con el argumento de par nombre-valor.'OptimizeHyperparameters' Solo puede modificar la validación cruzada mediante el argumento de par nombre-valor.'OptimizeHyperparameters''HyperparameterOptimizationOptions'

Opciones de regresión del kernel

contraer todo

, especificado como el par separado por comas que consta de un escalar positivo.Restricción de cuadro'BoxConstraint'

Este argumento sólo es válido cuando es (predeterminado) y no se especifica un valor para la intensidad del término de regularización.'Learner''svm''Lambda' Puede especificar o porque la restricción de cuadro () y la intensidad del término de regularización () están relacionadas por'BoxConstraint''Lambda'Cλ C = 1/(λn), donde está el número de observaciones (filas en).nX

Ejemplo: 'BoxConstraint',100

Tipos de datos: single | double

La mitad de la anchura de la banda sin distinción de épsilon, especificada como el par separado por comas que consta de un valor escalar no negativo o o no.'Epsilon''auto'

Para, la función determina el valor de as, que es una estimación de una décima de la desviación estándar utilizando el rango intercuartil de la variable de respuesta.'auto'fitrkernelEpsiloniqr(Y)/13.49Y Si es igual a cero, a continuación, establece el valor de 0,1.iqr(Y)fitrkernelEpsilon

sólo es válida cuando es.'Epsilon'Learnersvm

Ejemplo: 'Epsilon',0.3

Tipos de datos: single | double

Número de dimensiones del espacio expandido, especificado como el par separado por comas que consta de un entero positivo o de él.'NumExpansionDimensions''auto' Para, la función selecciona el número de cotas utilizando, donde está el número de predictores.'auto'fitrkernel2.^ceil(min(log2(p)+5,15))p

Ejemplo: 'NumExpansionDimensions',2^15

Tipos de datos: char | string | single | double

Parámetro de escala del kernel, especificado como el par separado por comas que consta de un escalar positivo o o un resultado. Obtiene la base aleatoria para la expansión de entidades aleatorias mediante el parámetro de escala del kernel.'KernelScale''auto'MATLAB® Para obtener más información, consulte.Expansión de características aleatorias

Si se especifica, se selecciona un parámetro de escala de kernel adecuado mediante un procedimiento heurístico.'auto'MATLAB Este procedimiento heurístico utiliza el submuestreo, por lo que las estimaciones pueden variar de una llamada a otra. Por lo tanto, para reproducir los resultados, establezca un número de semilla aleatoria utilizando antes del entrenamiento.rng

Ejemplo: 'KernelScale','auto'

Tipos de datos: char | string | single | double

Fuerza del término de regularización, especificada como el par separado por comas que consta de un escalar no negativo.'Lambda''auto'

Para, el valor de es 1/, donde está el número de observaciones (filas en).'auto''Lambda'nnX

Puede especificar o porque la restricción de cuadro () y la intensidad del término de regularización () están relacionadas por'BoxConstraint''Lambda'Cλ C = 1/(λn).

Ejemplo: 'Lambda',0.01

Tipos de datos: char | string | single | double

Tipo de modelo de regresión lineal, especificado como el par separado por comas que consta de y o.'Learner''svm''leastsquares'

En la siguiente tabla, f(x)=T(x)β+b.

  • es una observación (vector de fila) a partir de variables predictoras.xp

  • T(·) es una transformación de una observación (vector de fila) para la expansión de entidades. T(x) mapas enx p a un espacio de alta dimensionalidad (m).

  • es un vector de coeficientes.βm

  • es el sesgo escalar.b

ValorAlgoritmoRango de respuestaFunción de pérdida
'leastsquares'Regresión lineal a través de mínimos cuadrados ordinarios∊ (-∞, ∞)yError cuadrado medio (MSE): [y,f(x)]=12[yf(x)]2
'svm'Apoye la regresión de la máquina vectorialIgual que'leastsquares'Insensible a la Epsilon: [y,f(x)]=max[0,|yf(x)|ε]

Ejemplo: 'Learner','leastsquares'

Nivel de verbosidad, especificado como el par separado por comas que consta de y cualquiera o. controla la cantidad de información de diagnóstico'Verbose'01Verbose fitrkernel aparece en la línea de comandos.

ValorDescripción
0fitrkernel no muestra información de diagnóstico.
1fitrkernel muestra y almacena el valor de la función objetiva, la magnitud del degradado y otra información de diagnóstico. contiene la información de diagnóstico.FitInfo.History

Ejemplo: 'Verbose',1

Tipos de datos: single | double

Cantidad máxima de memoria asignada (en megabytes), especificada como el par separado por comas que consta de un escalar positivo.'BlockSize'

Si requiere más memoria que el valor de contener los datos de predictor transformados, utiliza una estrategia de bloque.fitrkernelBlockSizeMATLAB Para obtener más información sobre la estrategia en bloque, consulte.Algoritmos

Ejemplo: 'BlockSize',1e4

Tipos de datos: single | double

Secuencia numérica aleatoria para la reproducibilidad de la transformación de datos, especificada como el par separado por comas que consta de un objeto de secuencia aleatorio.'RandomStream' Para obtener más información, consulte.Expansión de características aleatorias

Se utiliza para reproducir las funciones de base aleatoria que utiliza para transformar los datos en un espacio de alta dimensión.'RandomStream'fitrkernelX Para obtener más información, consulte y.La gestión de la transmisión global (MATLAB)Crear y controlar un flujo de números aleatorios (MATLAB)

Ejemplo: 'RandomStream',RandStream('mlfg6331_64')

Transformación de respuesta, especificada como el par separado por comas que consta de y uno o un identificador de función.'ResponseTransform''none' El valor predeterminado es, que significa, o ninguna transformación.'none'@(y)y Para una función o una función que defina, utilice su manejador de funciones.MATLAB El identificador de función debe aceptar un vector (los valores de respuesta originales) y devolver un vector del mismo tamaño (los valores de respuesta transformados).

Ejemplo: Supongamos que crea un identificador de función que aplica una transformación exponencial a un vector de entrada mediante el uso de.myfunction = @(y)exp(y) A continuación, puede especificar la transformación de respuesta como.'ResponseTransform',myfunction

Tipos de datos: char | string | function_handle

Ponderaciones de observación, especificadas como el par separado por comas que consta de un vector numérico de valores positivos.'Weights' fitrkernel pesa las observaciones con los valores correspondientes en.XWeights El tamaño de debe ser igual, el número de observaciones (filas en).WeightsnX

fitrkernel Normaliza para sumar a 1.Weights

Tipos de datos: double | single

Opciones de validación cruzada

contraer todo

Indicador de validación cruzada, especificado como el par separado por comas que consta de y o.'Crossval''on''off'

Si se especifica, el software implementa la validación cruzada de 10 veces.'on'

Puede invalidar esta configuración de validación cruzada mediante el argumento de par nombre-valor, o Name.CVPartitionHoldoutKFoldLeaveout Solo puede usar un argumento de par nombre-valor de validación cruzada a la vez para crear un modelo validado de forma cruzada.

Ejemplo: 'Crossval','on'

Partición de validación cruzada, especificada como el par separado por comas que consta de un objeto de partición creado por.'CVPartition'cvpartitioncvpartition El objeto de partición especifica el tipo de validación cruzada y la indización para los conjuntos de entrenamiento y validación.

Para crear un modelo con validación cruzada, puede usar uno de estos cuatro argumentos de par nombre-valor solamente:,,, o.CVPartitionHoldoutKFoldLeaveout

Ejemplo: Supongamos que crea una partición aleatoria para la validación cruzada de 5 veces en 500 observaciones mediante el uso de.cvp = cvpartition(500,'KFold',5) A continuación, puede especificar el modelo con validación cruzada mediante.'CVPartition',cvp

Fracción de los datos utilizados para la validación de exclusión, especificado como el par separado por comas que consta de y un valor escalar en el intervalo (0,1).'Holdout' Si usted especifica, después el software completa estos pasos:'Holdout',p

  1. Seleccione aleatoriamente y Reserve% de los datos como datos de validación y capacite al modelo con el resto de los datos.p*100

  2. Almacene el modelo compacto y entrenado en la propiedad del modelo con validación cruzada.Trained

Para crear un modelo con validación cruzada, puede usar uno de estos cuatro argumentos de par nombre-valor solamente:,,, o.CVPartitionHoldoutKFoldLeaveout

Ejemplo: 'Holdout',0.1

Tipos de datos: double | single

Número de pliegues que se utilizarán en un modelo con validación cruzada, especificado como el par separado por comas y que consta de un valor entero positivo mayor que 1.'KFold' Si usted especifica, después el software completa estos pasos:'KFold',k

  1. Particionar aleatoriamente los datos en sets.k

  2. Para cada conjunto, Reserve el conjunto como datos de validación y entrene el modelo utilizando el otro k – 1 Establece.

  3. Almacene los modelos compactos y entrenados en las celdas de un vector de celda a-por-1 en la propiedad del modelo validado de forma cruzada.kkTrained

Para crear un modelo con validación cruzada, puede usar uno de estos cuatro argumentos de par nombre-valor solamente:,,, o.CVPartitionHoldoutKFoldLeaveout

Ejemplo: 'KFold',5

Tipos de datos: single | double

Marca de validación cruzada de Leave-One-out, especificada como el par separado por comas que consta de y o.'Leaveout''on''off' Si especifica, a continuación, para cada una de las observaciones (donde es el número de observaciones excluyendo las observaciones faltantes), el software completa estos pasos:'Leaveout','on'nn

  1. Reservar la observación como datos de validación, y entrenar el modelo utilizando el otro – 1 observaciones.n

  2. Almacene los modelos compactos y entrenados en las celdas de un vector de celda-por-1 en la propiedad del modelo validado de forma cruzada.nnTrained

Para crear un modelo con validación cruzada, puede usar uno de estos cuatro argumentos de par nombre-valor solamente:,,, o.CVPartitionHoldoutKFoldLeaveout

Ejemplo: 'Leaveout','on'

Controles de convergencia

contraer todo

Tolerancia relativa en los coeficientes lineales y el término de sesgo (intercepción), especificado como el par separado por comas que consta de un escalar no negativo.'BetaTolerance'

Dejar Bt=[βtbt], es decir, el vector de los coeficientes y el término de sesgo en la iteración de optimización.t Si BtBt1Bt2<BetaTolerance, la optimización finaliza.

Si también especifica, la optimización finaliza cuando el software satisface cualquier criterio de detención.GradientTolerance

Ejemplo: 'BetaTolerance',1e-6

Tipos de datos: single | double

Tolerancia de degradado absoluta, especificada como el par separado por comas que consta de un escalar no negativo.'GradientTolerance'

Dejar t ser el vector de degradado de la función objetiva con respecto a los coeficientes y el término de sesgo en la iteración de optimización.t Si t=max|t|<GradientTolerance, la optimización finaliza.

Si también especifica, la optimización finaliza cuando el software satisface cualquier criterio de detención.BetaTolerance

Ejemplo: 'GradientTolerance',1e-5

Tipos de datos: single | double

Tamaño del búfer del historial para la aproximación de hessian, especificado como el par separado por comas que consta de un entero positivo.'HessianHistorySize' En cada iteración, compone el hessian mediante el uso de estadísticas de las iteraciones más recientes.fitrkernelHessianHistorySize

Ejemplo: 'HessianHistorySize',10

Tipos de datos: single | double

Número máximo de iteraciones de optimización, especificadas como el par separado por comas y que consta de un entero positivo.'IterationLimit'

El valor predeterminado es 1000 si los datos transformados caben en la memoria, según lo especificado por.BlockSize De lo contrario, el valor predeterminado es 100.

Ejemplo: 'IterationLimit',500

Tipos de datos: single | double

Opciones de optimización de hiperparámetros

contraer todo

Parámetros para optimizar, especificados como el par separado por comas que consta de y uno de estos valores:'OptimizeHyperparameters'

  • — No optimice.'none'

  • Uso.'auto'{'KernelScale','Lambda','Epsilon'}

  • : Optimice todos los parámetros elegibles.'all'

  • Matriz de celdas de nombres de parámetro elegibles.

  • Vector de objetos, normalmente la salida de.optimizableVariablehiperparámetros

La optimización intenta minimizar la pérdida de validación cruzada (error) para variando los parámetros.fitrkernel Para controlar el tipo de validación cruzada y otros aspectos de la optimización, use el argumento de par nombre-valor.HyperparameterOptimizationOptions

Nota

valores reemplazan los valores que se establecen con otros argumentos de par nombre-valor.'OptimizeHyperparameters' Por ejemplo, si se establece en hace que los valores se apliquen.'OptimizeHyperparameters''auto''auto'

Los parámetros elegibles para son:fitrkernel

  • — busca entre valores positivos, de forma predeterminada, con escala logaritmo en el rango.Epsilonfitrkernel[1e-3,1e2]*iqr(Y)/1.349

  • — busca entre valores positivos, de forma predeterminada, con escala logaritmo en el rango.KernelScalefitrkernel[1e-3,1e3]

  • — busca entre valores positivos, por defecto escalado logaritmo en el rango, donde es el número de observaciones.Lambdafitrkernel[1e-3,1e3]/nn

  • — busca entre y.Learnerfitrkernel'svm''leastsquares'

  • : busca entre enteros positivos, de forma predeterminada, con escala de registro en el intervalo.NumExpansionDimensionsfitrkernel[100,10000]

Establezca parámetros no predeterminados pasando un vector de objetos que tienen valores no predeterminados.optimizableVariable Por ejemplo:

load carsmall params = hyperparameters('fitrkernel',[Horsepower,Weight],MPG); params(2).Range = [1e-4,1e6];

Pase como el valor de.params'OptimizeHyperparameters'

De forma predeterminada, la visualización iterativa aparece en la línea de comandos y los trazados aparecen según el número de hiperparámetros de la optimización. Para la optimización y los trazados, la función objetivo es log(1 + cross-validation loss) para la regresión y la tasa de clasificación errónea para la clasificación. Para controlar la visualización iterativa, establezca el campo del argumento de par nombre-valor.Verbose'HyperparameterOptimizationOptions' Para controlar los trazados, establezca el campo del argumento de par nombre-valor.ShowPlots'HyperparameterOptimizationOptions'

Para ver un ejemplo, vea.Optimizar la regresión del kernel

Ejemplo: 'OptimizeHyperparameters','auto'

Opciones de optimización, especificadas como el par separado por comas que consta de una estructura.'HyperparameterOptimizationOptions' Este argumento modifica el efecto del argumento de par nombre-valor.OptimizeHyperparameters Todos los campos de la estructura son opcionales.

Nombre de campoValoresPredeterminado
Optimizer
  • — Utilice la optimización bayesiana.'bayesopt' Internamente, esta configuración llama.bayesopt

  • : Utilice la búsqueda de cuadrícula con valores por dimensión.'gridsearch'NumGridDivisions

  • — Búsqueda aleatoria entre puntos.'randomsearch'MaxObjectiveEvaluations

búsquedas en orden aleatorio, utilizando muestreo uniforme sin sustitución de la rejilla.'gridsearch' Después de la optimización, puede obtener una tabla en orden de cuadrícula mediante el comando.sortrows(Mdl.HyperparameterOptimizationResults)

'bayesopt'
AcquisitionFunctionName

  • 'expected-improvement-per-second-plus'

  • 'expected-improvement'

  • 'expected-improvement-plus'

  • 'expected-improvement-per-second'

  • 'lower-confidence-bound'

  • 'probability-of-improvement'

Las funciones de adquisición cuyos nombres incluyen no producen resultados reproducibles porque la optimización depende del tiempo de ejecución de la función objetiva.per-second Las funciones de adquisición cuyos nombres incluyen modificar su comportamiento cuando están sobreexplotando un área.plus Para obtener más información, consulte.Tipos de función de adquisición

'expected-improvement-per-second-plus'
MaxObjectiveEvaluationsNúmero máximo de evaluaciones de funciones objetivas.para o, y toda la rejilla para30'bayesopt''randomsearch''gridsearch'
MaxTime

Límite de tiempo, especificado como real positivo. El límite de tiempo es en segundos, medido por y.tictoc El tiempo de ejecución puede exceder porque no interrumpe las evaluaciones de funciones.MaxTimeMaxTime

Inf
NumGridDivisionsPara el número de valores de cada dimensión.'gridsearch' El valor puede ser un vector de enteros positivos que da el número de valores para cada dimensión, o un escalar que se aplica a todas las dimensiones. Este campo se omite para las variables categóricas.10
ShowPlotsValor lógico que indica si se mostrarán los trazados. Si, este campo traza el mejor valor de la función objetiva con respecto al número de iteración.true Si hay uno o dos parámetros de optimización, y si es así, también traza un modelo de la función objetiva contra los parámetros.Optimizer'bayesopt'ShowPlotstrue
SaveIntermediateResultsValor lógico que indica si se guardan los resultados cuando es.Optimizer'bayesopt' Si, este campo sobrescribe una variable de espacio de trabajo denominada en cada iteración.true'BayesoptResults' La variable es un objeto.BayesianOptimizationfalse
Verbose

Mostrar en la línea de comandos.

  • — Sin visualización iterativa0

  • — Visualización iterativa1

  • — Visualización iterativa con información adicional2

Para obtener información detallada, vea el argumento de par nombre-valor.bayesoptVerbose

1
UseParallelValor lógico que indica si se debe ejecutar la optimización bayesiana en paralelo, lo que requiere.Parallel Computing Toolbox™ Para obtener más información, consulte.Optimización bayesiana paralelafalse
Repartition

Valor lógico que indica si se vuelve a particionar la validación cruzada en cada iteración. Si, el optimizador utiliza una sola partición para la optimización.false

normalmente proporciona los resultados más sólidos, ya que esta configuración tiene en cuenta el ruido de partición.true Sin embargo, para obtener buenos resultados, requiere al menos el doble de evaluaciones de función.true

false
No utilice más de uno de los tres nombres de campo siguientes.
CVPartitionUn objeto, creado por.cvpartitioncvpartitionSi no especifica ningún campo de validación cruzada'Kfold',5
HoldoutUn escalar en el rango que representa la fracción de exclusión.(0,1)
KfoldUn entero mayor que 1.

Ejemplo: 'HyperparameterOptimizationOptions',struct('MaxObjectiveEvaluations',60)

Tipos de datos: struct

Argumentos de salida

contraer todo

Modelo de regresión de kernel entrenado, devuelto como un objeto de modelo o objeto de modelo validado de forma cruzada.RegressionKernelRegressionPartitionedKernel

Si establece cualquiera de los argumentos de par nombre-valor,,, o, a continuación, es un modelo con validación cruzada.CrossValCVPartitionHoldoutKFoldLeaveoutMdlRegressionPartitionedKernel De lo contrario, es un modelo.MdlRegressionKernel

Para hacer referencia a las propiedades de, utilice notación de puntos.Mdl Por ejemplo, escriba en la ventana de comandos para mostrar el número de cotas del espacio expandido.Mdl.NumExpansionDimensions

Nota

A diferencia de otros modelos de regresión, y para el uso de memoria económica, un objeto de modelo no almacena los datos de entrenamiento o los detalles del proceso de entrenamiento (por ejemplo, historial de convergencia).RegressionKernel

Detalles de optimización, devueltos como una matriz de estructura, incluidos los campos descritos en esta tabla. Los campos contienen valores finales o las especificaciones del argumento de par nombre-valor.

CampoDescripción
Solver

Técnica de minimización de funciones objetivas:,, o.'LBFGS-fast''LBFGS-blockwise''LBFGS-tall' Para obtener más información, consulte.Algoritmos

LossFunctionFunción de pérdida. El error cuadrado medio (MSE) o el Epsilon-insensible, dependiendo del tipo de modelo de regresión lineal. Ver.Learner
LambdaFuerza del término de regularización. Ver.Lambda
BetaToleranceTolerancia relativa en los coeficientes lineales y el término de sesgo. Ver.BetaTolerance
GradientToleranceTolerancia de degradado absoluta. Ver.GradientTolerance
ObjectiveValueValor de la función objetiva cuando finaliza la optimización. La pérdida de regresión más el término de regularización componen la función objetiva.
GradientMagnitudeNorma infinita del vector de degradado de la función objetiva cuando finaliza la optimización. Ver.GradientTolerance
RelativeChangeInBetaCambios relativos en los coeficientes lineales y el término de sesgo cuando finaliza la optimización. Ver.BetaTolerance
FitTimeTiempo transcurrido, reloj de pared (en segundos) necesario para ajustar el modelo a los datos.
HistoryHistorial de la información de optimización. Este campo también incluye la información de optimización de la formación.Mdl Este campo está vacío () si se especifica.[]'Verbose',0 Para obtener más información, consulte y.VerboseAlgoritmos

Para acceder a los campos, utilice notación de puntos. Por ejemplo, para acceder al vector de los valores de función objetiva para cada iteración, escriba en la ventana de comandos.FitInfo.ObjectiveValue

Examinar la información facilitada para evaluar si la convergencia es satisfactoria.FitInfo

Optimización de validación cruzada de hiperparámetros, devueltos como un objeto o una tabla de hiperparámetros y valores asociados.BayesianOptimization La salida no está vacía cuando el valor de no es.'OptimizeHyperparameters''none' El valor de salida depende del valor de campo del argumento de par nombre-valor:Optimizer'HyperparameterOptimizationOptions'

Valor de campoOptimizerValor deHyperparameterOptimizationResults
predeterminado'bayesopt'Objeto de claseBayesianOptimization
O'gridsearch''randomsearch'Tabla de hiperparámetros utilizados, valores de función objetiva observados (pérdida de validación cruzada) y rango de observaciones de menor (mejor) a mayor (peor)

Limitaciones

  • no acepta las condiciones iniciales para los coeficientes lineales beta () y el término de sesgo () utilizado para determinar la función de decisión,fitrkernelβb f(x)=T(x)β+b.

  • no admite opciones de estandarización y validación cruzada.fitrkernel

  • no acepta entradas de tabla.fitrkernel

Más acerca de

contraer todo

Expansión de características aleatorias

La expansión de características aleatorias, como los sumideros de cocina aleatorios y Fastfood, es un esquema para aproximar los núcleos Gaussianos del algoritmo de regresión del kernel para Big Data de una manera computacionalmente eficiente.[1][2] La expansión de características aleatorias es más práctica para las aplicaciones de macrodatos que tienen grandes conjuntos de entrenamiento, pero también se pueden aplicar a conjuntos de datos más pequeños que caben en la memoria.

El algoritmo de regresión del kernel busca una función óptima que se desvíe de cada punto de datos de respuesta (yi) por valores no mayores que el margen Epsilon () después de mapear los Datos predictores en un espacio de alta dimensionalidad.ε

Algunos problemas de regresión no se pueden describir adecuadamente mediante un modelo lineal. En tales casos, obtenga un modelo de regresión no lineal reemplazando el producto de punto x1x2 con una función de kernel no lineal G(x1,x2)=φ(x1),φ(x2)Dónde Xi es la observación TH (vector de fila) yi φ(xi) es una transformación que asigna Xi a un espacio de alta dimensionalidad (llamado "truco del kernel"). Sin embargo, evaluar G(x1,x2) , la matriz Gram, para cada par de observaciones es costosa computacionalmente para un conjunto de datos grande (grande).n

El esquema de expansión de entidades aleatorias encuentra una transformación aleatoria para que su producto de punto se aprobe al kernel gaussiano. Es decir

G(x1,x2)=φ(x1),φ(x2)T(x1)T(x2)',

Dónde T(x) mapas enx p a un espacio de alta dimensionalidad (m). El esquema de sumidero aleatorio de la cocina utiliza la transformación aleatoria[1]

T(x)=m1/2exp(iZx')',

Dónde Zm×p es una muestra extraída de N(0,σ2) Y σ2 es una escala de kernel. Este esquema requiere O(mp) Computación y almacenamiento. El esquema Fastfood introduce otra base aleatoria en lugar de utilizar matrices Hadamard combinadas con matrices de escalado gaussiano.[2]VZ Esta base aleatoria reduce el costo de cálculo para O(mlogp) y reduce el almacenamiento a O(m).

Puede especificar valores para ym σ2, utilizando los argumentos de par nombre-valor de, respectivamente.NumExpansionDimensionsKernelScalefitrkernel

La función utiliza el esquema Fastfood para la expansión aleatoria de entidades y utiliza la regresión lineal para entrenar un modelo de regresión del kernel gaussiano.fitrkernel A diferencia de los solucionadores de la función, que requieren el cálculo de la matriz de Gram, el solucionador sólo necesita formar una matriz de tamaño por-, con típicamente mucho menor que para Big Data.fitrsvmnnfitrkernelnmmn

Restricción de cuadro

Una restricción de caja es un parámetro que controla la penalización máxima impuesta a las observaciones que se encuentran fuera del margen de épsilon () y ayuda a evitar el sobreajuste (regularización).ε El aumento de la restricción de caja puede conducir a tiempos de entrenamiento más largos.

La restricción de caja () y la fuerza de regularización () están relacionadas porCλ C = 1/(λn), donde está el número de observaciones.n

Algoritmos

fitrkernel minimiza la función objetiva regularizada utilizando un Solver de memoria limitada Broyden-Fletcher-Goldfarb-Shanno (LBFGS) con cresta (L2regularización. Para encontrar el tipo de solucionador LBFGS utilizado para el entrenamiento, escriba en la ventana de comandos.FitInfo.Solver

  • — Solucionador de LBFGS.'LBFGS-fast'

  • — Solucionador LBFGS con una estrategia en bloque.'LBFGS-blockwise' Si fitrkernel requiere más memoria que el valor de contener los datos de predictor transformados, a continuación, utiliza una estrategia de bloque.BlockSize

  • — Solucionador LBFGS con una estrategia en bloque para matrices altas.'LBFGS-tall'

Cuando fitrkernel utiliza una estrategia en bloque, fitrkernel implementa LBFGS distribuyendo el cálculo de la pérdida y el gradiente entre diferentes partes de los datos en cada iteración. Además fitrkernel reajusta las estimaciones iniciales de los coeficientes lineales y el término de sesgo al ajustar el modelo localmente a partes de los datos y combinar los coeficientes promediando. Si especifica,'Verbose',1 fitrkernel muestra información de diagnóstico para cada paso de datos y almacena la información en el campo de.HistoryFitInfo

Cuando fitrkernel no utiliza una estrategia en bloque, las estimaciones iniciales son ceros. Si especifica,'Verbose',1 fitrkernel muestra información de diagnóstico para cada iteración y almacena la información en el campo de.HistoryFitInfo

Referencias

[1] Rahimi, A., and B. Recht. “Random Features for Large-Scale Kernel Machines.” Advances in Neural Information Processing Systems. Vol. 20, 2008, pp. 1177–1184.

[2] Le, Q., T. Sarlós, and A. Smola. “Fastfood — Approximating Kernel Expansions in Loglinear Time.” Proceedings of the 30th International Conference on Machine Learning. Vol. 28, No. 3, 2013, pp. 244–252.

[3] Huang, P. S., H. Avron, T. N. Sainath, V. Sindhwani, and B. Ramabhadran. “Kernel methods match Deep Neural Networks on TIMIT.” 2014 IEEE International Conference on Acoustics, Speech and Signal Processing. 2014, pp. 205–209.

Capacidades ampliadas

Introducido en R2018a