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.

fitcecoc

Ajustar modelos multiclase para máquinas vectoriales de soporte u otros clasificadores

Sintaxis

Mdl = fitcecoc(Tbl,ResponseVarName)

Mdl = fitcecoc(Tbl,formula)

Mdl = fitcecoc(Tbl,Y)

Mdl = fitcecoc(X,Y)

Mdl = fitcecoc(___,Name,Value)

[Mdl,HyperparameterOptimizationResults] = fitcecoc(___,Name,Value)

Descripción

Mdl = fitcecoc(Tbl,ResponseVarName) devuelve un completo, entrenado, multiclase, utilizando los predictores de la tabla y las etiquetas de clase en . utiliza ( – 1)/2 modelos de máquina vectorial de soporte binario (SVM) utilizando el uno contra uno , donde está el número de etiquetas de clase únicas (niveles). es un modelo.modelo de códigos de salida de corrección de errores (ECOC)TblTbl.ResponseVarNamefitcecocKKdiseño de codificaciónKMdlClassificationECOC

Mdl = fitcecoc(Tbl,formula) devuelve un modelo ECOC utilizando los predictores de la tabla y las etiquetas de clase. es un modelo explicativo de la respuesta y un subconjunto de variables predictoras utilizadas para el entrenamiento.TblFórmulaTbl

Mdl = fitcecoc(Tbl,Y) devuelve un modelo ECOC utilizando los predictores de la tabla y las etiquetas de clase en vector .TblY

Mdl = fitcecoc(X,Y) devuelve un modelo ECOC entrenado utilizando los predictores y las etiquetas de clase.XY

Mdl = fitcecoc(___,Name,Value) devuelve un modelo ECOC con opciones adicionales especificadas por uno o más argumentos de par, utilizando cualquiera de las sintaxis anteriores.Name,Value

Por ejemplo, especifique diferentes alumnos binarios, un diseño de codificación diferente o para validar de forma cruzada. Se recomienda validar cruzadamente mediante el argumento pair.KfoldName,Value Los resultados de la validación cruzada determinan qué tan bien se generaliza el modelo.

[Mdl,HyperparameterOptimizationResults] = fitcecoc(___,Name,Value) también devuelve detalles de optimización de hiperparámetros cuando se especifica el argumento de par nombre-valor y se utilizan alumnos binarios lineales o del kernel.OptimizeHyperparameters Para otros , la propiedad de contiene los resultados.LearnersHyperparameterOptimizationResultsMdl

Ejemplos

Entrenar modelo multiclase con estudiantes de SVM

Entrene un modelo de códigos de salida de corrección de errores multiclase (ECOC) utilizando los alumnos binarios de la máquina vectorial de soporte (SVM).

Cargue el conjunto de datos de iris de Fisher. Especifique los datos del predictor y los datos de respuesta.XY

load fisheriris X = meas; Y = species;

Entrene un modelo ECOC multiclase utilizando las opciones predeterminadas.

Mdl = fitcecoc(X,Y)

Mdl =    ClassificationECOC              ResponseName: 'Y'     CategoricalPredictors: []                ClassNames: {'setosa'  'versicolor'  'virginica'}            ScoreTransform: 'none'            BinaryLearners: {3x1 cell}                CodingName: 'onevsone'     Properties, Methods  

es un modelo.MdlClassificationECOC De forma predeterminada, utiliza los alumnos binarios SVM y un diseño de codificación uno contra uno.fitcecoc Puede acceder a las propiedades mediante la notación de puntos.Mdl

Mostrar los nombres de clase y la matriz de diseño de codificación.

Mdl.ClassNames

ans = 3x1 cell array
    {'setosa'    }
    {'versicolor'}
    {'virginica' }

CodingMat = Mdl.CodingMatrix

CodingMat = 3×3

     1     1     0
    -1     0     1
     0    -1    -1

Un diseño de codificación uno contra uno para tres clases produce tres alumnos binarios. Las columnas corresponden a los alumnos y las filas corresponden a las clases.CodingMat El orden de clasees es el mismo que el orden en .Mdl.ClassNames Por ejemplo, es e indica que el software entrena al primer aprendiz binario SVM utilizando todas las observaciones clasificadas como y .CodingMat(:,1)[1; –1; 0]'setosa''versicolor' Porque corresponde a , es la clase positiva; corresponde a , por lo que es la clase negativa.'setosa'1'versicolor'–1

Puede acceder a cada alumno binario mediante la indexación de celdas y la notación de puntos.

Mdl.BinaryLearners{1}   % The first binary learner

ans =    classreg.learning.classif.CompactClassificationSVM              ResponseName: 'Y'     CategoricalPredictors: []                ClassNames: [-1 1]            ScoreTransform: 'none'                      Beta: [4x1 double]                      Bias: 1.4505          KernelParameters: [1x1 struct]     Properties, Methods  

Calcular el error de clasificación de la resustitución.

error = resubLoss(Mdl)

error = 0.0067 

El error de clasificación en los datos de entrenamiento es pequeño, pero el clasificador podría ser un modelo sobreajustado. Puede validar el clasificador mediante y calcular el error de clasificación de validación cruzada en su lugar.crossval

Modelo de clasificación lineal multiclase de tren

Entrenar un modelo ECOC compuesto por múltiples modelos binarios de clasificación lineal.

Cargue el conjunto de datos de PNL.

load nlpdata

es una matriz dispersa de datos predictores, y es un vector categórico de etiquetas de clase.XY Hay más de dos clases en los datos.

Cree una plantilla de modelo de clasificación lineal predeterminada.

t = templateLinear();

Para ajustar los valores predeterminados, consulte la página en.Name-Value Pair ArgumentstemplateLinear

Entrenar un modelo ECOC compuesto por varios modelos binarios de clasificación lineal que pueden identificar el producto dada la distribución de frecuencia de palabras en una página web de documentación. Para un tiempo de entrenamiento más rápido, transponga los datos del predictor y especifique que las observaciones corresponden a columnas.

X = X'; rng(1); % For reproducibility  Mdl = fitcecoc(X,Y,'Learners',t,'ObservationsIn','columns')

Mdl =    classreg.learning.classif.CompactClassificationECOC       ResponseName: 'Y'         ClassNames: [1x13 categorical]     ScoreTransform: 'none'     BinaryLearners: {78x1 cell}       CodingMatrix: [13x78 double]     Properties, Methods  

Como alternativa, puede entrenar un modelo ECOC compuesto por modelos de clasificación lineal predeterminados utilizando .'Learners','Linear'

Para conservar la memoria, devuelve modelos ECOC entrenados compuestos por alumnos de clasificación lineal en objetos de modelo.fitcecocCompactClassificationECOC

Clasificador ECOC multivalida

Valide de forma cruzada un clasificador ECOC con alumnos binarios SVM y calcule el error de clasificación generalizada.

Cargue el conjunto de datos de iris de Fisher. Especifique los datos del predictor y los datos de respuesta.XY

load fisheriris X = meas; Y = species; rng(1); % For reproducibility

Cree una plantilla sVM y estandarice los predictores.

t = templateSVM('Standardize',true)

t =  Fit template for classification SVM.                       Alpha: [0x1 double]              BoxConstraint: []                  CacheSize: []              CachingMethod: ''                 ClipAlphas: []     DeltaGradientTolerance: []                    Epsilon: []               GapTolerance: []               KKTTolerance: []             IterationLimit: []             KernelFunction: ''                KernelScale: []               KernelOffset: []      KernelPolynomialOrder: []                   NumPrint: []                         Nu: []            OutlierFraction: []           RemoveDuplicates: []            ShrinkagePeriod: []                     Solver: ''            StandardizeData: 1         SaveSupportVectors: []             VerbosityLevel: []                    Version: 2                     Method: 'SVM'                       Type: 'classification'  

es una plantilla sVM.t La mayoría de las propiedades del objeto de plantilla están vacías. Al entrenar el clasificador ECOC, el software establece las propiedades aplicables a sus valores predeterminados.

Entrene el clasificador ECOC y especifique el orden de clase.

Mdl = fitcecoc(X,Y,'Learners',t,...     'ClassNames',{'setosa','versicolor','virginica'});

es clasificador.MdlClassificationECOC Puede acceder a sus propiedades mediante la notación de puntos.

Valide cruzadamente mediante validación cruzada de 10 veces.Mdl

CVMdl = crossval(Mdl);

es un clasificador ECOC validado cruzadamente.CVMdlClassificationPartitionedECOC

Calcule el error de clasificación generalizada.

genError = kfoldLoss(CVMdl)

genError = 0.0400 

El error de clasificación generalizada es el 4%, lo que indica que el clasificador ECOC generaliza bastante bien.

Estimar probabilidades posteriores con clasificador ECOC

Entrene a un clasificador ECOC con los alumnos binarios SVM. Primero predecir las etiquetas de la muestra de entrenamiento y las probabilidades posteriores de clase. A continuación, prediga la probabilidad máxima de la clase posterior en cada punto de una cuadrícula. Visualice los resultados.

Cargue el conjunto de datos de iris de Fisher. Especifique las dimensiones de los pétalos como los predictores y los nombres de las especies como respuesta.

load fisheriris X = meas(:,3:4); Y = species; rng(1); % For reproducibility

Cree una plantilla SVM. Estandarice los predictores y especifique el kernel gaussiano.

t = templateSVM('Standardize',true,'KernelFunction','gaussian');

es una plantilla sVM.t La mayoría de sus propiedades están vacías. Cuando el software entrena el clasificador ECOC, establece las propiedades aplicables a sus valores predeterminados.

Entrene el clasificador ECOC utilizando la plantilla SVM. Transforme las puntuaciones de clasificación en probabilidades posteriores de clase (que se devuelven por o ) mediante el argumento de par nombre-valor.predictresubPredict'FitPosterior' Especifique el orden de clases mediante el argumento par nombre-valor.'ClassNames' Mostrar mensajes de diagnóstico durante el entrenamiento mediante el argumento de par nombre-valor.'Verbose'

Mdl = fitcecoc(X,Y,'Learners',t,'FitPosterior',true,...     'ClassNames',{'setosa','versicolor','virginica'},...     'Verbose',2);

Training binary learner 1 (SVM) out of 3 with 50 negative and 50 positive observations. Negative class indices: 2 Positive class indices: 1  Fitting posterior probabilities for learner 1 (SVM). Training binary learner 2 (SVM) out of 3 with 50 negative and 50 positive observations. Negative class indices: 3 Positive class indices: 1  Fitting posterior probabilities for learner 2 (SVM). Training binary learner 3 (SVM) out of 3 with 50 negative and 50 positive observations. Negative class indices: 3 Positive class indices: 2  Fitting posterior probabilities for learner 3 (SVM). 

es un modelo.MdlClassificationECOC La misma plantilla sVM se aplica a cada alumno binario, pero puede ajustar las opciones para cada alumno binario pasando un vector de celda de plantillas.

Predecir las etiquetas de la muestra de entrenamiento y las probabilidades posteriores de clase. Mostrar mensajes de diagnóstico durante el cálculo de etiquetas y probabilidades posteriores de clase mediante el argumento de par nombre-valor.'Verbose'

[label,~,~,Posterior] = resubPredict(Mdl,'Verbose',1);

Predictions from all learners have been computed. Loss for all observations has been computed. Computing posterior probabilities... 

Mdl.BinaryLoss

ans =  'quadratic' 

El software asigna una observación a la clase que produce la pérdida binaria promedio más pequeña. Dado que todos los alumnos binarios están calculando probabilidades posteriores, la función de pérdida binaria es .quadratic

Mostrar un conjunto aleatorio de resultados.

idx = randsample(size(X,1),10,1); Mdl.ClassNames

ans = 3x1 cell array
    {'setosa'    }
    {'versicolor'}
    {'virginica' }

table(Y(idx),label(idx),Posterior(idx,:),...     'VariableNames',{'TrueLabel','PredLabel','Posterior'})

ans=10×3 table
      TrueLabel         PredLabel                     Posterior               
    ______________    ______________    ______________________________________

    {'virginica' }    {'virginica' }     0.0039316     0.0039864       0.99208
    {'virginica' }    {'virginica' }      0.017065      0.018261       0.96467
    {'virginica' }    {'virginica' }      0.014946      0.015854        0.9692
    {'versicolor'}    {'versicolor'}    2.2197e-14       0.87318       0.12682
    {'setosa'    }    {'setosa'    }         0.999    0.00025091     0.0007464
    {'versicolor'}    {'virginica' }    2.2195e-14      0.059423       0.94058
    {'versicolor'}    {'versicolor'}    2.2194e-14       0.97002      0.029983
    {'setosa'    }    {'setosa'    }         0.999    0.00024989    0.00074741
    {'versicolor'}    {'versicolor'}     0.0085637       0.98259     0.0088481
    {'setosa'    }    {'setosa'    }         0.999    0.00025012    0.00074719

Las columnas de corresponden al orden de clase de .PosteriorMdl.ClassNames

Defina una cuadrícula de valores en el espacio predictor observado. Predecir las probabilidades posteriores para cada instancia de la cuadrícula.

xMax = max(X); xMin = min(X);  x1Pts = linspace(xMin(1),xMax(1)); x2Pts = linspace(xMin(2),xMax(2)); [x1Grid,x2Grid] = meshgrid(x1Pts,x2Pts);  [~,~,~,PosteriorRegion] = predict(Mdl,[x1Grid(:),x2Grid(:)]);

Para cada coordenada de la cuadrícula, trace la probabilidad máxima de la clase posterior entre todas las clases.

contourf(x1Grid,x2Grid,...         reshape(max(PosteriorRegion,[],2),size(x1Grid,1),size(x1Grid,2))); h = colorbar; h.YLabel.String = 'Maximum posterior'; h.YLabel.FontSize = 15;  hold on gh = gscatter(X(:,1),X(:,2),Y,'krk','*xd',8); gh(2).LineWidth = 2; gh(3).LineWidth = 2;  title('Iris Petal Measurements and Maximum Posterior') xlabel('Petal length (cm)') ylabel('Petal width (cm)') axis tight legend(gh,'Location','NorthWest') hold off

Acelere la formación de clasificadores ECOC mediante binning y computación paralela

Entrena a un clasificador ECOC uno contra todo usando un conjunto de árboles de decisión con divisiones sustitutas.GentleBoost Para acelerar el entrenamiento, bin predictores numéricos y utilizar la computación paralela. Binning solo es válido cuando se utiliza un alumno de árbol.fitcecoc Después del entrenamiento, calcule el error de clasificación mediante la validación cruzada de 10 veces. Tenga en cuenta que la informática paralela requiere Parallel Computing Toolbox™.

Cargar datos de muestra

Cargue e inspeccione el conjunto de datos.arrhythmia

load arrhythmia [n,p] = size(X)

n = 452 

p = 279 

isLabels = unique(Y); nLabels = numel(isLabels)

nLabels = 13 

tabulate(categorical(Y))

  Value    Count   Percent       1      245     54.20%       2       44      9.73%       3       15      3.32%       4       15      3.32%       5       13      2.88%       6       25      5.53%       7        3      0.66%       8        2      0.44%       9        9      1.99%      10       50     11.06%      14        4      0.88%      15        5      1.11%      16       22      4.87% 

El conjunto de datos contiene predictores y el tamaño de la muestra es relativamente pequeño.279452 De las 16 etiquetas distintas, sólo 13 se representan en la respuesta ( ).Y Cada etiqueta describe varios grados de arritmia, y el 54,20% de las observaciones están en clase.1

Entrenar clasificador ECOC uno contra todos

Cree una plantilla de conjunto. Debe especificar al menos tres argumentos: un método, un número de alumnos y el tipo de alumno. En este ejemplo, especifique para el método, para el número de alumnos y una plantilla de árbol de decisión que usa divisiones suplentes porque faltan observaciones.'GentleBoost'100

tTree = templateTree('surrogate','on'); tEnsemble = templateEnsemble('GentleBoost',100,tTree);

es un objeto de plantilla.tEnsemble La mayoría de sus propiedades están vacías, pero el software las llena con sus valores predeterminados durante el entrenamiento.

Entrene a un clasificador ECOC uno contra todo utilizando los conjuntos de árboles de decisión como estudiantes binarios. Para acelerar el entrenamiento, utilice binning y computación paralela.

• Binning ( ) — Cuando tiene un conjunto de datos de entrenamiento grande, puede acelerar el entrenamiento (una posible disminución de la precisión) mediante el argumento de par nombre-valor.'NumBins',50'NumBins' Este argumento solo es válido cuando se utiliza un alumno de árbol.fitcecoc Si especifica el valor, el software coloca cada predictor numérico en un número especificado de bins de equiprobables y, a continuación, crece árboles en los índices bin en lugar de los datos originales.'NumBins' Puede probar primero y, a continuación, cambiar el valor en función de la precisión y la velocidad de entrenamiento.'NumBins',50'NumBins'

• Computación paralela ( ) — Con una licencia de Parallel Computing Toolbox, puede acelerar el cálculo mediante la informática paralela, que envía a cada alumno binario a un trabajador del grupo.'Options',statset('UseParallel',true) El número de trabajadores depende de la configuración del sistema. Cuando se utilizan árboles de decisión para alumnos binarios, se paraleliza el entrenamiento mediante Intel® Threading Building Blocks (TBB) para sistemas de doble núcleo y superiores.fitcecoc Por lo tanto, especificar la opción no es útil en un solo equipo.'UseParallel' Utilice esta opción en un clúster.

Además, especifique que las probabilidades anteriores son 1/ , donde el número de clases distintas es 13.KK

options = statset('UseParallel',true); Mdl = fitcecoc(X,Y,'Coding','onevsall','Learners',tEnsemble,...                 'Prior','uniform','NumBins',50,'Options',options);

Starting parallel pool (parpool) using the 'local' profile ... Connected to the parallel pool (number of workers: 6). 

es un modelo.MdlClassificationECOC

Validación cruzada

Valide el clasificador ECOC mediante una validación cruzada de 10 veces.

CVMdl = crossval(Mdl,'Options',options);

Warning: One or more folds do not contain points from all the groups. 

es un modelo.CVMdlClassificationPartitionedECOC La advertencia indica que algunas clases no están representadas mientras el software entrena al menos un pliegue. Por lo tanto, esos pliegues no pueden predecir etiquetas para las clases que faltan. Puede inspeccionar los resultados de un pliegue utilizando la indexación de celdas y la notación de puntos. Por ejemplo, acceda a los resultados del primer pliegue introduciendo .CVMdl.Trained{1}

Utilice el clasificador ECOC validado cruzadamente para predecir las etiquetas de plegado de validación. Puede calcular la matriz de confusión utilizando .confusionchart Mueva y cambie el tamaño del gráfico cambiando la propiedad de posición interna para asegurarse de que los porcentajes aparecen en el resumen de filas.

oofLabel = kfoldPredict(CVMdl,'Options',options); ConfMat = confusionchart(Y,oofLabel,'RowSummary','total-normalized'); ConfMat.InnerPosition = [0.10 0.12 0.85 0.85];

Reproducir datos Binned

Reproduzca los datos del predictor en la lista utilizando la propiedad del modelo entrenado y la función.BinEdgesdiscretize

X = Mdl.X; % Predictor data Xbinned = zeros(size(X)); edges = Mdl.BinEdges; % Find indices of binned predictors. idxNumeric = find(~cellfun(@isempty,edges)); if iscolumn(idxNumeric)     idxNumeric = idxNumeric'; end for j = idxNumeric      x = X(:,j);     % Convert x to array if x is a table.     if istable(x)         x = table2array(x);     end     % Group x into bins by using the discretize function.     xbinned = discretize(x,[-inf; edges{j}; inf]);     Xbinned(:,j) = xbinned; end

contiene los índices bin, que van desde 1 hasta el número de ubicaciones, para los predictores numéricos. valores son para los predictores categóricos.XbinnedXbinned0 Si contiene s, entonces los valores correspondientes son s.XNaNXbinnedNaN

Optimizar clasificador ECOC

Optimice los hiperparámetros automáticamente utilizando .fitcecoc

Cargue el conjunto de datos.fisheriris

load fisheriris X = meas; Y = species;

Busque hiperparámetros que minimicen la pérdida de validación cruzada cinco veces mediante la optimización automática de hiperparámetros. Para reproducibilidad, establezca la semilla aleatoria y utilice la función de adquisición.'expected-improvement-plus'

rng default Mdl = fitcecoc(X,Y,'OptimizeHyperparameters','auto',...     'HyperparameterOptimizationOptions',struct('AcquisitionFunctionName',...     'expected-improvement-plus'))

|====================================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |       Coding | BoxConstraint|  KernelScale | |      | result |             | runtime     | (observed)  | (estim.)    |              |              |              | |====================================================================================================================| |    1 | Best   |     0.10667 |     0.90643 |     0.10667 |     0.10667 |     onevsone |       5.6939 |       200.36 | 

|    2 | Best   |        0.08 |      6.0692 |        0.08 |    0.081379 |     onevsone |       94.849 |    0.0032549 | 

|    3 | Accept |        0.08 |     0.75665 |        0.08 |     0.08003 |     onevsall |      0.01378 |     0.076021 | 

|    4 | Accept |        0.08 |     0.38313 |        0.08 |    0.080001 |     onevsall |          889 |       38.798 | 

|    5 | Best   |    0.073333 |     0.60261 |    0.073333 |    0.073337 |     onevsall |       17.142 |       1.7174 | 

|    6 | Accept |        0.26 |      19.481 |    0.073333 |    0.073337 |     onevsall |      0.88995 |    0.0010029 | 

|    7 | Accept |        0.08 |     0.66342 |    0.073333 |    0.073341 |     onevsall |      0.23012 |      0.34633 | 

|    8 | Best   |        0.04 |      1.1261 |        0.04 |    0.040007 |     onevsone |       100.53 |      0.10211 | 

|    9 | Accept |     0.12667 |     0.42644 |        0.04 |     0.04001 |     onevsone |    0.0015155 |      0.91412 | 

|   10 | Accept |    0.046667 |      3.8205 |        0.04 |    0.040017 |     onevsone |       931.08 |     0.040024 | 

|   11 | Accept |        0.04 |     0.42431 |        0.04 |    0.040003 |     onevsone |       965.69 |      0.36688 | 

|   12 | Accept |     0.33333 |       0.645 |        0.04 |    0.040005 |     onevsall |    0.0010224 |       17.726 | 

|   13 | Accept |    0.046667 |       12.11 |        0.04 |    0.040003 |     onevsall |       892.53 |      0.35788 | 

|   14 | Accept |    0.046667 |     0.49748 |        0.04 |    0.039989 |     onevsone |       963.47 |       6.6814 | 

|   15 | Accept |        0.04 |     0.71768 |        0.04 |     0.03999 |     onevsone |    0.0010354 |    0.0010571 | 

|   16 | Accept |    0.046667 |     0.38383 |        0.04 |    0.039987 |     onevsone |    0.0011208 |    0.0078247 | 

|   17 | Accept |        0.04 |      1.3681 |        0.04 |    0.039982 |     onevsall |       916.38 |        1.868 | 

|   18 | Accept |     0.10667 |     0.63667 |        0.04 |    0.039982 |     onevsone |       993.53 |       989.56 | 

|   19 | Accept |        0.04 |      0.4792 |        0.04 |    0.039981 |     onevsone |     0.028541 |    0.0037104 | 

|   20 | Accept |        0.04 |       0.336 |        0.04 |    0.039991 |     onevsone |      0.75471 |       0.0221 | 

|====================================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |       Coding | BoxConstraint|  KernelScale | |      | result |             | runtime     | (observed)  | (estim.)    |              |              |              | |====================================================================================================================| |   21 | Accept |        0.04 |     0.46469 |        0.04 |    0.039964 |     onevsone |    0.0011513 |    0.0021711 | 

|   22 | Accept |    0.046667 |      2.9031 |        0.04 |    0.039792 |     onevsall |       978.75 |       1.0047 | 

|   23 | Accept |        0.04 |     0.45458 |        0.04 |     0.03979 |     onevsone |       965.54 |       1.0173 | 

|   24 | Accept |        0.04 |     0.57964 |        0.04 |    0.039801 |     onevsone |       11.578 |     0.048162 | 

|   25 | Accept |    0.046667 |     0.58721 |        0.04 |    0.039603 |     onevsone |       909.35 |       0.1889 | 

|   26 | Accept |        0.04 |     0.32227 |        0.04 |    0.039541 |     onevsone |       82.422 |      0.81772 | 

|   27 | Accept |        0.04 |     0.42088 |        0.04 |    0.039528 |     onevsone |     0.061877 |    0.0080194 | 

|   28 | Accept |        0.04 |     0.40175 |        0.04 |    0.039658 |     onevsone |    0.0050147 |    0.0026878 | 

|   29 | Accept |        0.04 |     0.45809 |        0.04 |    0.039677 |     onevsone |       526.28 |       1.2964 | 

|   30 | Accept |        0.04 |     0.60377 |        0.04 |    0.039693 |     onevsall |       945.22 |        4.473 | 

__________________________________________________________ Optimization completed. MaxObjectiveEvaluations of 30 reached. Total function evaluations: 30 Total elapsed time: 115.3634 seconds. Total objective function evaluation time: 59.0296  Best observed feasible point:      Coding     BoxConstraint    KernelScale     ________    _____________    ___________      onevsone       100.53          0.10211    Observed objective function value = 0.04 Estimated objective function value = 0.039693 Function evaluation time = 1.1261  Best estimated feasible point (according to models):      Coding     BoxConstraint    KernelScale     ________    _____________    ___________      onevsone      0.0050147       0.0026878   Estimated objective function value = 0.039693 Estimated function evaluation time = 0.40195 

Mdl =    ClassificationECOC                          ResponseName: 'Y'                 CategoricalPredictors: []                            ClassNames: {'setosa'  'versicolor'  'virginica'}                        ScoreTransform: 'none'                        BinaryLearners: {3x1 cell}                            CodingName: 'onevsone'     HyperparameterOptimizationResults: [1x1 BayesianOptimization]     Properties, Methods  

Modelo ECOC multiclase train con SMMs y tall Arrays

Cree dos modelos ECOC multiclase entrenados en datos altos. Utilice los estudiantes binarios lineales para uno de los modelos y los estudiantes binarios del kernel para el otro. Compare el error de clasificación de resustitución de los dos modelos.

En general, puede realizar la clasificación multiclase de datos altos mediante el uso de alumnos binarios lineales o del kernel.fitcecoc Cuando se utiliza para entrenar un modelo en matrices altas, no se pueden utilizar los alumnos binarios de SVM directamente.fitcecoc Sin embargo, puede utilizar modelos de clasificación binaria lineal o del kernel que utilicen STm.

Al realizar cálculos en matrices altas, MATLAB® utiliza un grupo paralelo (predeterminado si tiene Parallel Computing Toolbox™) o la sesión local de MATLAB. Si desea ejecutar el ejemplo utilizando la sesión local de MATLAB cuando tiene Parallel Computing Toolbox, puede cambiar el entorno de ejecución global mediante la función.mapreducer

Cree un almacén de datos que haga referencia a la carpeta que contiene el conjunto de datos de iris de Fisher. Especifique los valores como datos que faltan para que los reemplace por valores.'NA'datastoreNaN Cree versiones altas de los datos de predictor y respuesta.

ds = datastore('fisheriris.csv','TreatAsMissing','NA'); t = tall(ds);

Starting parallel pool (parpool) using the 'local' profile ... Connected to the parallel pool (number of workers: 6). 

X = [t.SepalLength t.SepalWidth t.PetalLength t.PetalWidth]; Y = t.Species;

Estandarizar los datos del predictor.

Z = zscore(X);

Entrene un modelo ECOC multiclase que utilice datos altos y estudiantes binarios lineales. De forma predeterminada, cuando se pasan matrices altas a , el software entrena a los alumnos binarios lineales que utilizan SM.fitcecoc Dado que los datos de respuesta solo contienen tres clases únicas, cambie el esquema de codificación de uno contra todo (que es el valor predeterminado cuando se utilizan datos altos) a uno frente a uno (que es el valor predeterminado cuando se utilizan datos en memoria).

Para reproducibilidad, establezca las semillas de los generadores de números aleatorios que utilizan y .rngtallrng Los resultados pueden variar en función del número de trabajadores y del entorno de ejecución de las matrices altas. Para obtener más información, consulte .Control Where Your Code Runs

rng('default')  tallrng('default') mdlLinear = fitcecoc(Z,Y,'Coding','onevsone')

Training binary learner 1 (Linear) out of 3. Training binary learner 2 (Linear) out of 3. Training binary learner 3 (Linear) out of 3. 

mdlLinear =    classreg.learning.classif.CompactClassificationECOC       ResponseName: 'Y'         ClassNames: {'setosa'  'versicolor'  'virginica'}     ScoreTransform: 'none'     BinaryLearners: {3×1 cell}       CodingMatrix: [3×3 double]     Properties, Methods  

es un modelo compuesto por tres estudiantes binarios.mdlLinearCompactClassificationECOC

Entrene un modelo ECOC multiclase que utilice datos altos y estudiantes binarios del kernel. En primer lugar, cree un objeto para especificar las propiedades de los alumnos binarios del kernel; en particular, aumentar el número de dimensiones de expansión atemplateKernel

<math display="block">

<mrow>

<msup>

<mrow>

<mn>2</mn>

</mrow>

<mrow>

<mn>1</mn>

<mn>6</mn>

</mrow>

</msup>

</mrow>

</math>

.

tKernel = templateKernel('NumExpansionDimensions',2^16)

tKernel =  Fit template for classification Kernel.               BetaTolerance: []                  BlockSize: []              BoxConstraint: []                    Epsilon: []     NumExpansionDimensions: 65536          GradientTolerance: []         HessianHistorySize: []             IterationLimit: []                KernelScale: []                     Lambda: []                    Learner: 'svm'               LossFunction: []                     Stream: []             VerbosityLevel: []                    Version: 1                     Method: 'Kernel'                       Type: 'classification'  

De forma predeterminada, los alumnos binarios del kernel utilizan SVMs.

Pase el objeto y cambie el esquema de codificación a uno contra uno.templateKernelfitcecoc

mdlKernel = fitcecoc(Z,Y,'Learners',tKernel,'Coding','onevsone')

Training binary learner 1 (Kernel) out of 3. Training binary learner 2 (Kernel) out of 3. Training binary learner 3 (Kernel) out of 3. 

mdlKernel =    classreg.learning.classif.CompactClassificationECOC       ResponseName: 'Y'         ClassNames: {'setosa'  'versicolor'  'virginica'}     ScoreTransform: 'none'     BinaryLearners: {3×1 cell}       CodingMatrix: [3×3 double]     Properties, Methods  

es también un modelo compuesto por tres estudiantes binarios.mdlKernelCompactClassificationECOC

Compare el error de clasificación de resustitución de los dos modelos.

errorLinear = gather(loss(mdlLinear,Z,Y))

Evaluating tall expression using the Parallel Pool 'local': - Pass 1 of 1: Completed in 1.5 sec Evaluation completed in 1.5 sec 

errorLinear = 0.0333 

errorKernel = gather(loss(mdlKernel,Z,Y))

Evaluating tall expression using the Parallel Pool 'local': - Pass 1 of 1: Completed in 17 sec Evaluation completed in 17 sec 

errorKernel = 0.0067 

clasifica erróneamente un porcentaje menor de los datos de entrenamiento que .mdlKernelmdlLinear

Argumentos de entrada

Tbl — Datos de muestra

Mesa

Datos de ejemplo, especificados como una tabla. Cada fila de corresponde a una observación, y cada columna corresponde a un predictor.Tbl Opcionalmente, puede contener una columna adicional para la variable de respuesta.Tbl No se aceptan variables de varias columnas y matrices de celdas distintas de las matrices de celdas de vectores de caracteres.

Si contiene la variable de respuesta y desea utilizar todas las variables restantes como predictores, especifique la variable de respuesta mediante .TblTblResponseVarName

Si contiene la variable de respuesta y desea utilizar solo un subconjunto de las variables restantes como predictores, especifique una fórmula mediante .TblTblFórmula

Si no contiene la variable de respuesta, especifique una variable de respuesta mediante .TblY La longitud de la variable de respuesta y el número de filas deben ser iguales.Tbl

Nota

Para el entrenamiento de modelos de clasificación lineal o de kernel, no admite tablas.fitcecoc Es decir, si es o , contiene una plantilla de alumno de modelo de clasificación lineal (consulte ), o contiene una plantilla de alumno de clasificación del núcleo (consulte ), no puede proporcionar , , o .Learners'linear''kernel'templateLineartemplateKernelTblResponseVarNameFórmula Proporcione una matriz de datos predictores ( ) y una matriz de respuestas ( ) en su lugar.XY

Tipos de datos: table

ResponseVarName — Nombre de la variable de respuesta

nombre de la variable enTbl

Nombre de la variable de respuesta, especificado como el nombre de una variable en .Tbl

Debe especificar como vector de caracteres o escalar de cadena.ResponseVarName Por ejemplo, si la variable de respuesta se almacena como , especifice como .YTbl.Y'Y' De lo contrario, el software trata todas las columnas de , incluidos , como predictores al entrenar el modelo.TblY

La variable de respuesta debe ser una matriz categórica, de carácter o de cadena, un vector lógico o numérico o una matriz de celdas de vectores de caracteres. Si es una matriz de caracteres, cada elemento de la variable de respuesta debe corresponder a una fila de la matriz.Y

Se recomienda especificar el orden de las clases mediante el argumento de par nombre-valor.ClassNames

Tipos de datos: char | string

formula — Modelo explicativo de variable de respuesta y subconjunto de variables predictoras

vector de caracteres | cuerda escalar

Modelo explicativo de la variable de respuesta y un subconjunto de las variables predictoras, especificadas como vector de caracteres o escalar de cadena en el formulario.'Y~X1+X2+X3' En este formulario, representa la variable de respuesta y , , y representa las variables predictoras.YX1X2X3

Para especificar un subconjunto de variables como predictores para entrenar el modelo, utilice una fórmula.Tbl Si especifica una fórmula, el software no utiliza ninguna variable que no aparezca en .TblFórmula

Los nombres de variable de la fórmula deben ser ambos nombres de variable en ( ) como identificadores válidos.TblTbl.Properties.VariableNamesMATLAB^®

Puede verificar los nombres de las variables mediante la función.Tblisvarname El código siguiente devuelve logical ( ) para cada variable que tiene un nombre de variable válido.1true Si los nombres de variable en no son válidos, a continuación, convertirlos mediante la función.

cellfun(@isvarname,Tbl.Properties.VariableNames)

Tblmatlab.lang.makeValidName

Tbl.Properties.VariableNames = matlab.lang.makeValidName(Tbl.Properties.VariableNames);

Tipos de datos: char | string

Y — Etiquetas de clase

matriz categórica | matriz de caracteres | matriz de cadenas | vector lógico | vector numérico | matriz celular de vectores de caracteres

Etiquetas de clase a las que se entrena el modelo ECOC, especificadas como una matriz categórica, de carácter o de cadena, un vector lógico o numérico o una matriz de celdas de vectores de caracteres.

Si es una matriz de caracteres, cada elemento debe corresponder a una fila de la matriz.Y

La longitud y el número de filas de o debe ser igual.YTblX

Se recomienda especificar el orden de clases mediante el argumento de par nombre-valor.ClassNames

Tipos de datos: categorical | char | string | logical | single | double | cell

X — Datos del predictor

matriz completa | matriz dispersa

Datos del predictor, especificados como una matriz completa o dispersa.

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

Para especificar los nombres de los predictores en el orden de su aparición en , utilice el argumento de par nombre-valor.XPredictorNames

Nota

• Para los alumnos de clasificación lineal, si orienta para que las observaciones se correspondan con columnas y especifique , puede experimentar una reducción significativa en el tiempo de optimización-ejecución.X'ObservationsIn','columns'

• Para todos los demás alumnos, oriente para que las observaciones correspondan a filas.X

• fitcecoc admite matrices dispersas solo para entrenar modelos de clasificación lineal.

Tipos de datos: double | single

Nota

El software trata , vector de caracteres vacíos ( ), cadena vacía ( ), y elementos como datos que faltan.NaN''""<missing><undefined> El software elimina las filas correspondientes a los valores que faltan en .XY Sin embargo, el tratamiento de los valores que faltan en varía entre los estudiantes binarios.X Para obtener más información, consulte las funciones de entrenamiento de los alumnos binarios: , , , , , , , , , o .fitcdiscrfitckernelfitcknnfitclinearfitcnbfitcsvmfitctreefitcensemble La eliminación de observaciones disminuye el entrenamiento efectivo o el tamaño de la muestra de validación cruzada.

Argumentos de par nombre-valor

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

Ejemplo: especifica usar árboles de decisión para todos los alumnos binarios, un diseño de codificación uno contra uno e implementar una validación cruzada de 10 veces.'Learners','tree','Coding','onevsone','CrossVal','on'

Nota

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

Opciones de clasificador ECOC

'Coding' — Diseño de codificación

'onevsone' (predeterminado) | 'allpairs' | 'binarycomplete' | 'denserandom' | 'onevsall' | 'ordinal' | 'sparserandom' | 'ternarycomplete' | matriz numérica

Nombre de diseño de codificación, especificado como el par separado por comas que consta de una matriz numérica o un valor en esta tabla.'Coding'

Valor	Número de estudiantes binarios	Descripción
Y'allpairs''onevsone'	( – 1)/2KK	Para cada alumno binario, una clase es positiva, otra es negativa y el software ignora el resto. Este diseño agota todas las combinaciones de asignaciones de pares de clases.
'binarycomplete'	$$2^{(K-1)}-1$$	Este diseño divide las clases en todas las combinaciones binarias y no omite ninguna clase. Para cada alumno binario, todas las asignaciones de clase son y con al menos una clase positiva y negativa en la asignación.-11
'denserandom'	Aleatorio, pero aproximadamente 10 registros2K	Para cada alumno binario, el software asigna clases aleatoriamente en clases positivas o negativas, con al menos uno de cada tipo. Para obtener más información, consulte .Matrices de diseño de codificación aleatoria
'onevsall'	K	Para cada alumno binario, una clase es positiva y el resto son negativos. Este diseño agota todas las combinaciones de asignaciones de clases positivas.
'ordinal'	– 1K	Para el primer alumno binario, la primera clase es negativa y el resto positivo. Para el segundo alumno binario, las dos primeras clases son negativas, el resto positivo, etc.
'sparserandom'	Aleatorio, pero aproximadamente 15 registros2K	Para cada alumno binario, el software asigna aleatoriamente clases como positivas o negativas con probabilidad 0,25 para cada uno, e ignora las clases con probabilidad 0,5. Para obtener más información, consulte .Matrices de diseño de codificación aleatoria
'ternarycomplete'	$$\left(3^K-2^{(K+1)}+1\right)/2$$	Este diseño divide las clases en todas las combinaciones ternarias. Todas las asignaciones de clases son , , y con al menos una clase positiva y una clase negativa en la asignación.0-11

También puede especificar un diseño de codificación mediante una matriz de codificación personalizada. La matriz de codificación personalizada es una matriz -by-.KL Cada fila corresponde a una clase y cada columna corresponde a un alumno binario. El orden de clases (filas) corresponde al orden en .ClassNames Componga la matriz siguiendo estas pautas:

• Cada elemento de la matriz de codificación personalizada debe ser , , o , y el valor debe corresponder a una asignación de clase dicotómica.-101 Esta tabla describe el significado de , es decir, la clase que el alumno asigna a las observaciones en la clase .Coding(i,j)ji

  Valor	Asignación de clase sin dicotómica
  –1	El alumno asigna observaciones en clase a una clase negativa.ji
  0	Antes del entrenamiento, el alumno elimina las observaciones en clase del conjunto de datos.ji
  1	El alumno asigna observaciones en clase a una clase positiva.ji

• Cada columna debe contener al menos una o .-11

• Para todos los índices de columna, de tal manera que , , no puede ser igual y no puede ser igual a .ijijCoding(:,i)Coding(:,j)Coding(:,i)-Coding(:,j)

• Todas las filas de la matriz de codificación personalizada deben ser diferentes.

Para obtener más información sobre la forma de matrices de diseño de codificación personalizadas, consulte .Matrices de diseño de codificación personalizadas

Ejemplo: 'Coding','ternarycomplete'

Tipos de datos: char | string | double | single | int16 | int32 | int64 | int8

'FitPosterior' — Indicador que indica si se deben transformar las puntuaciones en probabilidades posteriores

Ofalse0 (predeterminado) | Otrue1

Marcador que indica si se deben transformar las puntuaciones en probabilidades posteriores, especificados como el par separado por comas que consta de y un ( ) o ( ).'FitPosterior'true1false0

Si es , entonces el software transforma las puntuaciones de clasificación de aprendizaje binario a probabilidades posteriores.FitPosteriortrue Puede obtener probabilidades posteriores utilizando kfoldPredict, predictO resubPredict.

no admite probabilidades posteriores apropiadas si:fitcecoc

• El método de conjunto es , , , , o .AdaBoostM2LPBoostRUSBoostRobustBoostTotalBoost

• Los alumnos binarios ( ) son modelos de clasificación lineal es decir, lineales o de kernel que implementan SVM.Learners Para obtener probabilidades posteriores para los modelos de clasificación lineal o del núcleo, implemente la regresión logística en su lugar.

Ejemplo: 'FitPosterior',true

Tipos de datos: logical

'Learners' — Plantillas de aprendizaje binario

'svm' (predeterminado) | 'discriminant' | 'kernel' | 'knn' | 'linear' | 'naivebayes' | 'tree' | objeto de plantilla | vector de celda de objetos de plantilla

Plantillas de aprendizaje binario, especificadas como el par separado por comas que consta de un vector de caracteres, un escalar de cadena, un objeto de plantilla o un vector de celda de objetos de plantilla.'Learners' En concreto, puede especificar clasificadores binarios como SVM y los conjuntos que utilizan , , y , para resolver problemas multiclase.GentleBoostLogitBoostRobustBoost Sin embargo, también admite modelos multiclase como clasificadores binarios.fitcecoc

• Si es un vector de caracteres o un escalar de cadena, el software entrena a cada alumno binario utilizando los valores predeterminados del algoritmo especificado.Learners Esta tabla resume los algoritmos disponibles.

  Valor	Descripción
  'discriminant'	Análisis discriminatorio. Para ver las opciones predeterminadas, consulte .templateDiscriminant
  'kernel'	Modelo de clasificación del núcleo. Para ver las opciones predeterminadas, consulte .templateKernel
  'knn'	-vecinos más cercanos.k Para ver las opciones predeterminadas, consulte .templateKNN
  'linear'	Modelo de clasificación lineal. Para ver las opciones predeterminadas, consulte .templateLinear
  'naivebayes'	Bayes ingenuos. Para ver las opciones predeterminadas, consulte .templateNaiveBayes
  'svm'	Svm. Para ver las opciones predeterminadas, consulte .templateSVM
  'tree'	Arboles de clasificación. Para ver las opciones predeterminadas, consulte .templateTree

• Si es un objeto de plantilla, cada alumno binario entrena de acuerdo con las opciones almacenadas.Learners Puede crear un objeto de plantilla utilizando:

  • , para análisis discriminatorios.templateDiscriminant

  • , para el aprendizaje en conjunto.templateEnsemble Al menos debe especificar el método de aprendizaje ( ), el número de alumnos ( ) y el tipo de alumno ( ).MethodNLearnLearners No se puede utilizar el método ensemble para el aprendizaje binario.AdaBoostM2

  • , para la clasificación del núcleo.templateKernel

  • , para -vecinos más cercanos.templateKNNk

  • , para clasificación lineal.templateLinear

  • , para los bayes ingenuos.templateNaiveBayes

  • , para SVM.templateSVM

  • , para árboles de clasificación.templateTree

• Si es un vector de celda de objetos de plantilla, entonces:Learners

  • Cell corresponde al alumno binario (en otras palabras, columna de la matriz de diseño de codificación) y el vector de celda debe tener longitud . es el número de columnas en la matriz de diseño de codificación.jjjLL Para obtener más información, consulte .Coding

  • Para utilizar una de las funciones de pérdida integradas para la predicción, todos los alumnos binarios deben devolver una puntuación en el mismo rango. Por ejemplo, no puede incluir aprendizajes binarios SVM predeterminados con los alumnos binarios de Bayes ingenuos predeterminados. El primero devuelve una puntuación en el intervalo (-,o), y el segundo devuelve una probabilidad posterior como una puntuación. De lo contrario, debe proporcionar una pérdida personalizada como identificador de función para funciones como predict Y loss.

  • No puede especificar plantillas de alumno sin modelo de clasificación lineal con ninguna otra plantilla.

  • Del mismo modo, no puede especificar plantillas de alumnos del modelo de clasificación del kernel con ninguna otra plantilla.

De forma predeterminada, el software entrena a los alumnos mediante plantillas SVM predeterminadas.

Ejemplo: 'Learners','tree'

'NumBins' — Número de ubicaciones para predictores numéricos

(vacío)[] (predeterminado) | scalar entero positivo

Número de ubicaciones para predictores numéricos, especificado como el par separado por comas que consta de un escalar entero positivo.'NumBins' Este argumento sólo es válido cuando fitcecoc utiliza un alumno de árbol, es decir, es o un objeto de plantilla creado mediante , o un objeto de plantilla creado mediante el uso de alumnos débiles de árbol.'Learner''tree'templateTreetemplateEnsemble

• Si el valor está vacío (predeterminado), el software no bin ningún predictor.'NumBins'

• Si especifica el valor como un escalar entero positivo, el software coloca cada predictor numérico en un número especificado de bins equiprobables y, a continuación, crece árboles en los índices de ubicación en lugar de los datos originales.'NumBins'

  • Si el valor supera el número ( ) de valores únicos para un predictor,'NumBins'u fitcecoc bins el predictor en contenedores.u

  • fitcecoc no bin predictores categóricos.

Cuando se utiliza un conjunto de datos de entrenamiento grande, esta opción de binning acelera el entrenamiento, pero provoca una posible disminución de la precisión. Puede probar primero y, a continuación, cambiar el valor en función de la precisión y la velocidad de entrenamiento.'NumBins',50'NumBins'

Un modelo entrenado almacena los bordes de la ubicación en la propiedad.BinEdges

Ejemplo: 'NumBins',50

Tipos de datos: single | double

'NumConcurrent' — Número de estudiantes binarios entrenados simultáneamente

1 (predeterminado) | scalar entero positivo

Número de alumnos binarios entrenados simultáneamente, especificado como el par separado por comas que consta de un escalar entero positivo.'NumConcurrent' El valor predeterminado es , lo que significa que entrena a los alumnos binarios secuencialmente.1fitcecoc

Nota

Esta opción solo se aplica cuando se utiliza en matrices altas.fitcecoc Consulte para obtener más información.Matrices altas

Tipos de datos: single | double

'ObservationsIn' — Dimensión de observación de datos predictor

'rows' (predeterminado) | 'columns'

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

Nota

• Para los alumnos de clasificación lineal, si orienta para que las observaciones se correspondan con columnas y especifique , puede experimentar una reducción significativa en el tiempo de optimización-ejecución.X'ObservationsIn','columns'

• Para todos los demás alumnos, oriente para que las observaciones correspondan a filas.X

Ejemplo: 'ObservationsIn','columns'

'Verbose' — Nivel de verbosidad

0 (predeterminado) | 1 | 2

Nivel de detalle, especificado como el par separado por comas que consta de y , , o . controla la cantidad de información de diagnóstico por alumno binario que el software muestra en la ventana de comandos.'Verbose'012Verbose

En esta tabla se resumen las opciones de nivel de detalle disponibles.

Valor	Descripción
0	El software no muestra información de diagnóstico.
1	El software muestra mensajes de diagnóstico cada vez que entrena a un nuevo alumno binario.
2	El software muestra mensajes de diagnóstico adicionales cada vez que entrena a un nuevo alumno binario.

Cada alumno binario tiene su propio nivel de detalle que es independiente de este argumento de par nombre-valor. Para cambiar el nivel de detalle de un alumno binario, cree un objeto de plantilla y especifique el argumento de par nombre-valor.'Verbose' A continuación, pase el objeto de plantilla mediante el argumento de par nombre-valor.fitcecoc'Learners'

Ejemplo: 'Verbose',1

Tipos de datos: double | single

Opciones de validación cruzada

'CrossVal' — Bandera para entrenar clasificador oriundo

'off' (predeterminado) | 'on'

Marcar para entrenar un clasificador validado cruzado, especificado como el par separado por comas que consta de y o .'Crossval''on''off'

Si especifica , el software entrena un clasificador validado cruzadamente con 10 pliegues.'on'

Puede invalidar esta configuración de validación cruzada mediante uno de los argumentos de par , , o nombre-valor.CVPartitionHoldoutKFoldLeaveout Solo puede usar un argumento de par nombre-valor de validación cruzada a la vez para crear un modelo validado entre sí.

Alternativamente, valide más adelante pasando aMdl crossval.

Ejemplo: 'Crossval','on'

'CVPartition' — Partición de validación cruzada

[] (predeterminado) | objeto de particióncvpartition

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

Para crear un modelo validado entre referencias cruzadas, puede utilizar uno de estos cuatro argumentos de par nombre-valor solo: , , , o .CVPartitionHoldoutKFoldLeaveout

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

'Holdout' — Fracción de datos para la validación de retención

valor escalar en el rango (0,1)

Fracción de los datos utilizados para la validación de retención, especificada 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 y reserve aleatoriamente % de los datos como datos de validación y entrene el modelo con el resto de los datos.p*100

2. Almacene el modelo compacto y entrenado en la propiedad del modelo validado de forma cruzada.Trained

Para crear un modelo validado entre referencias cruzadas, puede utilizar uno de estos cuatro argumentos de par nombre-valor solo: , , , o .CVPartitionHoldoutKFoldLeaveout

Ejemplo: 'Holdout',0.1

Tipos de datos: double | single

'KFold' — Número de pliegues

10 (predeterminado) | valor entero positivo mayor que 1

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

1. Particione aleatoriamente los datos en conjuntos.k

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

3. Almacene los modelos compactos y entrenados en las celdas de un vector de celda -by-1 en la propiedad del modelo validado cruzadamente.kkTrained

Para crear un modelo validado entre referencias cruzadas, puede utilizar uno de estos cuatro argumentos de par nombre-valor solo: , , , o .CVPartitionHoldoutKFoldLeaveout

Ejemplo: 'KFold',5

Tipos de datos: single | double

'Leaveout' — Dejar un indicador de validación cruzada

'off' (predeterminado) | 'on'

Deje el indicador de validación cruzada uno-out, especificado como el par separado por comas que consta de y o .'Leaveout''on''off' Si especifica , entonces, para cada una de las observaciones, dónde está , el software:'Leaveout','on'nnsize(Mdl.X,1)

1. Reserva la observación como datos de validación y entrena el modelo utilizando las otras observaciones – 1n

2. Almacena los modelos compactos y entrenados en las celdas de un vector de celda -by-1 en la propiedad del modelo validado cruzadamente.nnTrained

Para crear un modelo validado entre referencias cruzadas, puede utilizar una de estas cuatro opciones solo: , , , o .CVPartitionHoldoutKFoldLeaveout

Nota

No se recomienda dejar un solo para validar modelos ECOC de validación cruzada compuestos por alumnos de modelos de clasificación lineal o de kernel.

Ejemplo: 'Leaveout','on'

Otras opciones de clasificación

'CategoricalPredictors' — Lista de predictores categóricos

vector de enteros positivos | vector lógico | matriz de caracteres | matriz de cadenas | matriz celular de vectores de caracteres | 'all'

Lista de predictores categóricos, especificada como el par separado por comas que consta de y uno de los valores de esta tabla.'CategoricalPredictors'

Valor	Descripción
Vector de enteros positivos	Cada entrada del vector es un valor de índice correspondiente a la columna de los datos predictores ( o ) que contiene una variable categórica.XTbl
Vector lógico	Una entrada significa que la columna correspondiente de datos predictores ( o ) es una variable categórica.trueXTbl
Matriz de caracteres	Cada fila de la matriz es el nombre de una variable predictora. Los nombres deben coincidir con las entradas de .PredictorNames Rellena los nombres con espacios en blanco adicionales para que cada fila de la matriz de caracteres tenga la misma longitud.
Matriz de cadenas o matriz de celdas de vectores de caracteres	Cada elemento de la matriz es el nombre de una variable predictora. Los nombres deben coincidir con las entradas de .PredictorNames
'todos'	Todos los predictores son categóricos.

La especificación de es apropiada si:'CategoricalPredictors'

• Al menos un predictor es categórico y todos los estudiantes binarios son árboles de clasificación, estudiantes ingenuos de Bayes, SVM o conjuntos de árboles de clasificación.

• Todos los predictores son categóricos y al menos un alumno binario es NN.k

Si especifica para cualquier otro alumno, el software advierte que no puede entrenar a ese alumno binario.'CategoricalPredictors' Por ejemplo, el software no puede entrenar a los alumnos del modelo de clasificación lineal o del núcleo mediante predictores categóricos.

Cada alumno identifica y trata los predictores categóricos de la misma manera que la función de ajuste correspondiente al alumno. Vea los alumnos más cercanos, los estudiantes ingenuos de Bayes, los alumnos de SVM y los que aprenden árboles.'CategoricalPredictors'fitcknnk'CategoricalPredictors'fitcnb'CategoricalPredictors'fitcsvm'CategoricalPredictors'fitctree

Ejemplo: 'CategoricalPredictors','all'

Tipos de datos: single | double | logical | char | string | cell

'ClassNames' — Nombres de las clases a utilizar para la formación

matriz categórica | matriz de caracteres | matriz de cadenas | vector lógico | vector numérico | matriz celular de vectores de caracteres

Nombres de clases que se usan para el entrenamiento, especificados como el par separado por comas que consta de y una matriz categórica, de carácter o de cadena, un vector lógico o numérico, o una matriz de celdas de vectores de caracteres. debe tener el mismo tipo de datos que .'ClassNames'ClassNamesY

Si es una matriz de caracteres, cada elemento debe corresponder a uno de la matriz.ClassNamesFila

Utilícelo para:ClassNames

• Ordene las clases durante el entrenamiento.

• Especifique el orden de cualquier dimensión de argumento de entrada o salida que corresponda al orden de clases. Por ejemplo, se utiliza para especificar el orden de las dimensiones o el orden de columna de las puntuaciones de clasificación devueltas por .ClassNamesCostpredict

• Seleccione un subconjunto de clases para el entrenamiento. Por ejemplo, supongamos que el conjunto de todos los nombres de clase distintos en es .Y{'a','b','c'} Para entrenar el modelo mediante observaciones de clases y solo, especifique .'a''c''ClassNames',{'a','c'}

El valor predeterminado para es el conjunto de todos los nombres de clase distintos en .ClassNamesY

Ejemplo: 'ClassNames',{'b','g'}

Tipos de datos: categorical | char | string | logical | single | double | cell

'Cost' — Coste de clasificación errónea

matriz cuadrada | matriz de estructura

Coste de clasificación errónea, especificado como el par separado por comas que consta de una matriz o estructura cuadrada.'Cost' Si especifica:

• La matriz cuadrada , entonces es el costo de clasificar un punto en clase si su clase verdadera es .CostCost(i,j)ji Es decir, las filas corresponden a la clase true y las columnas corresponden a la clase predicha. Para especificar el orden de clases para las filas y columnas correspondientes de , especifique además el argumento de par nombre-valor.CostClassNames

• La estructura , a continuación, debe tener dos campos:S

  • , que contiene los nombres de clase como una variable del mismo tipo de datos queS.ClassNamesY

  • , que contiene la matriz de costes con filas y columnas ordenadas como enS.ClassificationCostsS.ClassNames

El valor predeterminado es ones(K) - eye(K)Dónde K es el número de clases distintas.

Ejemplo: 'Cost',[0 1 2 ; 1 0 2; 2 2 0]

Tipos de datos: double | single | struct

'Options' — Opciones de computación paralela

[] (predeterminado) | estructura devuelta porstatset

Opciones de computación paralela, especificadas como el par separado por comas que consta de y una matriz de estructura devuelta por .'Options'statset Estas opciones requieren .Parallel Computing Toolbox™ fitcecoc utiliza , , y campos.'Streams''UseParallel''UseSubtreams'

Esta tabla resume las opciones disponibles.

Opción	Descripción
'Streams'	Un objeto o matriz de celdas de dichos objetos.RandStream Si no especifica , el software utiliza la secuencia o secuencias predeterminadas.Streams Si especifica , utilice un único objeto, excepto cuando se aseeifen lo siguiente:Streams Tiene un grupo paralelo abierto. Es.UseParalleltrue Es.UseSubstreamsfalse En ese caso, utilice una matriz de celdas del mismo tamaño que el grupo paralelo. Si un grupo paralelo no está abierto, el software intenta abrir uno (dependiendo de sus preferencias) y debe proporcionar una sola secuencia de números aleatorios.Streams
'UseParallel'	Si tiene , puede invocar un grupo de trabajadores estableciendo .Parallel Computing Toolbox'UseParallel',true el fitcecoc función envía cada alumno binario a un trabajador del grupo. Cuando se utilizan árboles de decisión para estudiantes binarios, fitcecoc paraleliza el entrenamiento mediante bloques de creación de roscado (TBB) para sistemas de doble núcleo y superiores.Intel® Por lo tanto, especificar la opción no es útil en un solo equipo.'UseParallel' Utilice esta opción en un clúster. Para obtener más información sobre TBB, consulte .Intelhttps://software.intel.com/en-us/intel-tbb
'UseSubstreams'	Establézalo para calcular en paralelo mediante la secuencia especificada por .true'Streams' El valor predeterminado es .false Por ejemplo, establezca en un tipo que permita subsecuencias, como o .Streams'mlfg6331_64''mrg32k3a'

Una práctica recomendada para garantizar resultados más predecibles es usar y crear explícitamente un grupo paralelo antes de invocar la informática paralela medianteparpool (Parallel Computing Toolbox) fitcecoc.

Ejemplo: 'Options',statset('UseParallel',true)

Tipos de datos: struct

'PredictorNames' — Nombres de variables predictoras

matriz de cadenas de nombres únicos | matriz de células de vectores de caracteres únicos

Nombres de variables predictoras, especificados como el par separado por comas que consta de y una matriz de cadenas de nombres únicos o matriz de celdas de vectores de caracteres únicos.'PredictorNames' La funcionalidad de depende de la forma en que proporcione los datos de entrenamiento.'PredictorNames'

• Si proporciona y , entonces puede utilizar para dar las variables predictoras en los nombres.XY'PredictorNames'X

  • El orden de los nombres en debe corresponder al orden de columna de .PredictorNamesX Es decir, es el nombre de , es el nombre de , y así sucesivamente.PredictorNames{1}X(:,1)PredictorNames{2}X(:,2) Además, y debe ser igual.size(X,2)numel(PredictorNames)

  • De forma predeterminada, es .PredictorNames{'x1','x2',...}

• Si proporciona , entonces puede utilizar para elegir qué variables predictoras utilizar en el entrenamiento.Tbl'PredictorNames' Es decir fitcecoc utiliza sólo las variables predictoras en y la variable de respuesta en el entrenamiento.PredictorNames

  • debe ser un subconjunto de y no puede incluir el nombre de la variable de respuesta.PredictorNamesTbl.Properties.VariableNames

  • De forma predeterminada, contiene los nombres de todas las variables predictoras.PredictorNames

  • Es una buena práctica especificar los predictores para el entrenamiento usando uno o solo.'PredictorNames'Fórmula

Ejemplo: 'PredictorNames',{'SepalLength','SepalWidth','PetalLength','PetalWidth'}

Tipos de datos: string | cell

'Prior' — Probabilidades anteriores

'empirical' (predeterminado) | 'uniform' | vector numérico | matriz de estructura

Probabilidades anteriores para cada clase, especificadas como el par separado por comas que consta de y un valor en esta tabla.'Prior'

Valor	Descripción
'empirical'	Las probabilidades anteriores de la clase son las frecuencias relativas de la clase en .Y
'uniform'	Todas las probabilidades anteriores de clase son iguales a 1/ , donde está el número de clases.KK
vector numérico	Cada elemento es una probabilidad previa de clase. Ordene los elementos según o especifique el orden utilizando el argumento de par nombre-valor.Mdl.ClassNamesClassNames El software normaliza los elementos de tal forma que sume a .1
Estructura	Una estructura con dos campos:S contiene los nombres de clase como una variable del mismo tipo que .S.ClassNamesY contiene un vector de las probabilidades anteriores correspondientes.S.ClassProbs El software normaliza los elementos de tal forma que sume a .1

Para obtener más detalles sobre cómo el software incorpora probabilidades anteriores de clase, véase .Probabilidades y costos anteriores

Ejemplo: struct('ClassNames',{{'setosa','versicolor','virginica'}},'ClassProbs',1:3)

Tipos de datos: single | double | char | string | struct

'ResponseName' — Nombre de la variable de respuesta

'Y' (predeterminado) | vector de caracteres | cuerda escalar

Nombre de la variable de respuesta, especificado como el par separado por comas que consta de un vector de caracteres o un escalar de cadena.'ResponseName'

• Si proporciona , puede usar para especificar un nombre para la variable de respuesta.Y'ResponseName'

• Si suministra o , entonces no puede utilizar .ResponseVarNameFórmula'ResponseName'

Ejemplo: 'ResponseName','response'

Tipos de datos: char | string

'ScoreTransform' — Transformación de puntuación

'none' (predeterminado) | 'doublelogit' | 'invlogit' | 'ismax' | 'logit' | manija de la función | ...

Transformación de puntuación, especificada como el par separado por comas que consta de un vector de caracteres, un escalar de cadena o un identificador de función.'ScoreTransform'

En esta tabla se resumen los vectores de caracteres disponibles y los escalares de cadena.

Valor	Descripción
'doublelogit'	1/(1 +e–2x)
'invlogit'	log( / (1 – ))xx
'ismax'	Establece la puntuación de la clase con la puntuación más alta en , y establece las puntuaciones de todas las demás clases en10
'logit'	1/(1 +e–x)
O'none''identity'	(sin transformación)x
'sign'	–1 para <0 0 para 0 0 para 0 1 para > 0x x x
'symmetric'	2 – 1x
'symmetricismax'	Establece la puntuación de la clase con la puntuación más alta en , y establece las puntuaciones de todas las demás clases en1–1
'symmetriclogit'	2/(1 +e–x) – 1

Para una función o una función que defina, utilice su identificador de función para la transformación de puntuación.MATLAB El identificador de función debe aceptar una matriz (las puntuaciones originales) y devolver una matriz del mismo tamaño (las puntuaciones transformadas).

Ejemplo: 'ScoreTransform','logit'

Tipos de datos: char | string | function_handle

'Weights' — Pesos de observación

vector numérico de valores positivos | nombre de la variable enTbl

Pesos de observación, especificados como el par separado por comas que consta de un vector numérico de valores positivos o el nombre de una variable en .'Weights'Tbl El software sopesa las observaciones en cada fila de o con el valor correspondiente en .XTblWeights El tamaño de debe ser igual al número de filas de o .WeightsXTbl

Si especifica los datos de entrada como una tabla , puede ser el nombre de una variable que contenga un vector numérico.TblWeightsTbl En este caso, debe especificar como vector de caracteres o escalar de cadena.Weights Por ejemplo, si el vector de ponderaciones se almacena como , especifice como .WTbl.W'W' De lo contrario, el software trata todas las columnas de , incluidos , como predictores o la respuesta al entrenar el modelo.TblW

El software se normaliza para sumar hasta el valor de la probabilidad anterior en la clase respectiva.Weights

De forma predeterminada, esWeights ones(n,1)Dónde n es el número de observaciones en o .XTbl

Tipos de datos: double | single | char | string

Optimización de hiperparámetros

'OptimizeHyperparameters' — Parámetros para optimizar

'none' (predeterminado) | 'auto' | 'all' | matriz de cadenas o matriz de celdas de nombres de parámetros elegibles | vector de objetosoptimizableVariable

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

• — No optimizar.'none'

• — Utilizar junto con los parámetros predeterminados para los :'auto'{'Coding'}Learners

  • (predeterminado) —Learners'svm'{'BoxConstraint','KernelScale'}

  • • —Learners'discriminant'{'Delta','Gamma'}

  • • —Learners'kernel'{'KernelScale','Lambda'}

  • • —Learners'knn'{'Distance','NumNeighbors'}

  • • —Learners'linear'{'Lambda','Learner'}

  • • —Learners'naivebayes'{'DistributionNames','Width'}

  • • —Learners'tree'{'MinLeafSize'}

• — Optimizar todos los parámetros elegibles.'all'

• Matriz de cadenas o matriz de celdas de nombres de parámetros elegibles

• Vector de objetos, normalmente la salida deoptimizableVariablehyperparameters

La optimización intenta minimizar la pérdida de validación cruzada (error) para variar los parámetros.fitcecoc Para obtener información sobre la pérdida de validación cruzada en un contexto diferente, consulte .Classification Loss Para controlar el tipo de validación cruzada y otros aspectos de la optimización, utilice el par nombre-valor.HyperparameterOptimizationOptions

Nota

los valores reemplazan los valores que establezca utilizando otros argumentos de par nombre-valor.'OptimizeHyperparameters' Por ejemplo, establecer para hacer que se apliquen los valores.'OptimizeHyperparameters''auto''auto'

Los parámetros elegibles para son:fitcecoc

• — búsquedas entre y .Codingfitcecoc'onevsall''onevsone'

• Los hiperparámetros elegibles para el elegido, tal como se especifica en esta tabla.Learners

  Estudiantes	Hiperparámetros elegibles (Bold - Predeterminado)	Rango predeterminado
  'discriminant'	Delta	Escalado de registros en el rango[1e-6,1e3]
  	DiscrimType	Y'linear''quadratic''diagLinear''diagQuadratic''pseudoLinear''pseudoQuadratic'
  	Gamma	Valores reales en[0,1]
  'kernel'	Lambda	Valores positivos escalado en registro en el rango[1e-3/NumObservations,1e3/NumObservations]
  	KernelScale	Valores positivos escalado en registro en el rango[1e-3,1e3]
  	Learner	Y'svm''logistic'
  	NumExpansionDimensions	Números enteros escalados en el intervalo[100,10000]
  'knn'	Distance	Y'cityblock''chebychev''correlation''cosine''euclidean''hamming''jaccard''mahalanobis''minkowski''seuclidean''spearman'
  	DistanceWeight	Y'equal''inverse''squaredinverse'
  	Exponent	Los valores positivos en[0.5,3]
  	NumNeighbors	Valores enteros positivos escalado en registro en el rango[1, max(2,round(NumObservations/2))]
  	Standardize	Y'true''false'
  'linear'	Lambda	Valores positivos escalado en registro en el rango[1e-5/NumObservations,1e5/NumObservations]
  	Learner	Y'svm''logistic'
  	Regularization	Y'ridge''lasso'
  'naivebayes'	DistributionNames	Y'normal''kernel'
  	Width	Valores positivos escalado en registro en el rango[MinPredictorDiff/4,max(MaxPredictorRange,MinPredictorDiff)]
  	Kernel	Y'normal''box''epanechnikov''triangle'
  'svm'	BoxConstraint	Valores positivos escalado en registro en el rango[1e-3,1e3]
  	KernelScale	Valores positivos escalado en registro en el rango[1e-3,1e3]
  	KernelFunction	Y'gaussian''linear''polynomial'
  	PolynomialOrder	Enteros en el rango[2,4]
  	Standardize	Y'true''false'
  'tree'	MaxNumSplits	Números enteros escalados en el intervalo[1,max(2,NumObservations-1)]
  	MinLeafSize	Números enteros escalados en el intervalo[1,max(2,floor(NumObservations/2))]
  	NumVariablesToSample	Enteros en el rango[1,max(2,NumPredictors)]
  	SplitCriterion	Y'gdi''deviance''twoing'

  Alternativamente, utilice con el elegido, comohyperparametersLearners

  load fisheriris % hyperparameters requires data and learner params = hyperparameters('fitcecoc',meas,species,'svm');

  Para ver los hiperparámetros elegibles y predeterminados, examine .params

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

load fisheriris params = hyperparameters('fitcecoc',meas,species,'svm'); params(2).Range = [1e-4,1e6];

Pase como el valor de .paramsOptimizeHyperparameters

De forma predeterminada, la visualización iterativa aparece en la línea de comandoy los trazados aparecen según el número de hiperparámetros de la optimización. Para la optimización y las gráficas, 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 obtener un ejemplo, consulte .Optimizar clasificador ECOC

Ejemplo: 'auto'

'HyperparameterOptimizationOptions' — Opciones para la optimización

Estructura

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

Nombre del campo	Valores	Predeterminado
Optimizer	— Utilice la optimización bayesiana.'bayesopt' Internamente, esta configuración llama a .bayesopt — Utilice la búsqueda de cuadrícula con valores por dimensión.'gridsearch'NumGridDivisions — Buscar al azar entre puntos.'randomsearch'MaxObjectiveEvaluations búsquedas en un orden aleatorio, utilizando muestreo uniforme sin reemplazo de la cuadrícula.'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 objetivo.per-second Las funciones de adquisición cuyos nombres incluyen modifican su comportamiento cuando están sobreexplotando un área.plus Para obtener más información, consulte .Acquisition Function Types	'expected-improvement-per-second-plus'
MaxObjectiveEvaluations	Número máximo de evaluaciones de funciones objetivas.	para o , y toda la cuadrícula para30'bayesopt''randomsearch''gridsearch'
MaxTime	Límite de tiempo, especificado como un real positivo. El límite de tiempo es en segundos, medido por y .tictoc El tiempo de ejecución puede superar porque no interrumpe las evaluaciones de funciones.MaxTimeMaxTime	Inf
NumGridDivisions	Para , el número de valores en cada dimensión.'gridsearch' El valor puede ser un vector de enteros positivos que dan 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
ShowPlots	Valor lógico que indica si se deben mostrar trazados. Si , este campo traza el mejor valor de función objetivo con respecto al número de iteración.true Si hay uno o dos parámetros de optimización, y si es , también se traza un modelo de la función objetivo con los parámetros.Optimizer'bayesopt'ShowPlots	true
SaveIntermediateResults	Valor lógico que indica si se deben guardar los resultados cuando es .Optimizer'bayesopt' Si , este campo sobrescribe una variable de área de trabajo denominada en cada iteración.true'BayesoptResults' La variable es un objeto.BayesianOptimization	false
Verbose	Visualice en la línea de comandos. — Sin visualización iterativa0 — Visualización iterativa1 — Pantalla iterativa con información adicional2 Para obtener más información, consulte el argumento de par nombre-valor.bayesoptVerbose	1
UseParallel	Valor lógico que indica si se debe ejecutar la optimización bayesiana en paralelo, lo que requiere .Parallel Computing Toolbox Debido a la no reproducibilidad de la sincronización paralela, la optimización bayesiana paralela no produce necesariamente resultados reproducibles. Para obtener más información, consulte .Parallel Bayesian Optimization	false
Repartition	Valor lógico que indica si se debe volver a particionar la validación cruzada en cada iteración. Si , el optimizador utiliza una sola partición para la optimización.false por lo general da los resultados más robustos porque esta configuración tiene en cuenta el ruido de partición.true Sin embargo, para obtener buenos resultados, se requiere al menos el doble de evaluaciones de funciones.true	false
No utilice más de uno de los tres nombres de campo siguientes.
CVPartition	Un objeto, tal como lo creó .cvpartitioncvpartition	si no especifica ningún campo de validación cruzada'Kfold',5
Holdout	Un escalar en el rango que representa la fracción de retención.(0,1)
Kfold	Un entero mayor que 1.

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

Tipos de datos: struct

Argumentos de salida

Mdl — Modelo ECOC entrenado

objeto modeloClassificationECOC | objeto modeloCompactClassificationECOC | objeto de modelo validado cruzadamenteClassificationPartitionedECOC | objeto de modelo validado cruzadamenteClassificationPartitionedLinearECOC | objeto de modelo validado cruzadamenteClassificationPartitionedKernelECOC

Clasificador ECOC entrenado, devuelto como un objeto o objeto de modelo, o un objeto de modelo , , o validado entre referencias cruzadas.ClassificationECOCCompactClassificationECOCClassificationPartitionedECOCClassificationPartitionedLinearECOCClassificationPartitionedKernelECOC

Esta tabla muestra cómo los tipos de objetos de modelo devueltos por fitcecoc depende del tipo de aprendizaje binario que especifique y si realiza la validación cruzada.

Estudiantes de Modelos de Clasificación Lineal	Estudiantes del modelo de clasificación del núcleo	Validación cruzada	Objeto de modelo devuelto
No	No	No	ClassificationECOC
No	No	Sí	ClassificationPartitionedECOC
Sí	No	No	CompactClassificationECOC
Sí	No	Sí	ClassificationPartitionedLinearECOC
No	Sí	No	CompactClassificationECOC
No	Sí	Sí	ClassificationPartitionedKernelECOC

HyperparameterOptimizationResults — Descripción de la optimización de validación cruzada de hiperparámetros

ObjetoBayesianOptimization | tabla de hiperparámetros y valores asociados

Descripción de la optimización de validación cruzada de hiperparámetros, devuelta como un objeto o una tabla de hiperparámetros y valores asociados. no está vacío cuando el argumento de par nombre-valor no está vacío y el argumento de par nombre-valor designa a los alumnos binarios lineales o del kernel.BayesianOptimizationHyperparameterOptimizationResultsOptimizeHyperparametersLearners El valor depende de la configuración del argumento de par nombre-valor:HyperparameterOptimizationOptions

• (predeterminado) — Objeto de clase'bayesopt'BayesianOptimization

• o — Tabla de hiperparámetros utilizados, valores de función objetivo observados (pérdida de validación cruzada) y rango de observación de menor (mejor) a mayor (peor)'gridsearch''randomsearch'

Tipos de datos: table

Limitaciones

• Para el entrenamiento de modelos de clasificación lineal o de kernel, no admite tablas.fitcecoc Es decir, si es o , contiene una plantilla de alumno de modelo de clasificación lineal (consulte ), o contiene una plantilla de alumno del modelo de clasificación del núcleo ( consulte ), no puede proporcionar , , o .Learners'linear''kernel'templateLineartemplateKernelTblResponseVarNameFórmula Proporcione una matriz de datos predictores ( ) y una matriz de respuestas ( ) en su lugar.XY

• fitcecoc admite matrices dispersas solo para entrenar modelos de clasificación lineal. Para todos los demás modelos, proporcione una matriz completa de datos predictores en su lugar.

Más acerca de

Pérdida binaria

A es una función de la puntuación de clase y clasificación que determina qué tan bien un alumno binario clasifica una observación en la clase.pérdida binaria

Supongamos lo siguiente:

• M_kj es el elemento ( , ) de la matriz de diseño de codificación (es decir, el código correspondiente a la clase de aprendiz binario).kjMkj

• s_j es la puntuación de aprendiz binario para una observación.j

• es la función de pérdida binaria.g

• $$\widehat{k}$$ es la clase pronosticada para la observación.

En , la clase que produce la suma mínima de las pérdidas binarias sobre los estudiantes binarios determina la clase pronosticada de una observación, es decir,decodificación basada en pérdidas[Escalera et al.]

$$\widehat{k}=\underset{k}{\text{argmin}}{\displaystyle \sum _{j=1}^L\left|m_{kj}\right|g}(m_{kj},s_j).$$

En , la clase que produce el promedio mínimo de las pérdidas binarias sobre los estudiantes binarios determina la clase pronosticada de una observación, es decir,decodificación ponderada por pérdida[Escalera et al.]

$$\widehat{k}=\underset{k}{\text{argmin}}\frac{{\displaystyle \sum _{j=1}^L\left|m_{kj}\right|g}(m_{kj},s_j)}{{\displaystyle \sum }_{j=1}^L\left|m_{kj}\right|}.$$

sugieren que la decodificación ponderada por pérdidas mejora la precisión de la clasificación al mantener los valores de pérdida para todas las clases en el mismo rango dinámico.Allwein et al.

Esta tabla resume las funciones de pérdida soportadas, donde y y_j es una etiqueta de clase para un alumno binario en particular (en el conjunto de números 1,1,0o), s_j es la puntuación para la observación, y (jgy y_j,s_j).

Valor	Descripción	Dominio de puntuación	g(y yj,sj)
'binodeviance'	Desviación binomial	(–,o)	log[1 + exp(–2y yjsj)]/[2log(2)]
'exponential'	Exponencial	(–,o)	exp(–y yjsj)/2
'hamming'	Hamming	[0,1] o (–,o)	[1 – signo(y yjsj)]/2
'hinge'	Bisagra	(–,o)	max(0,1 – y yjsj)/2
'linear'	Lineal	(–,o)	(1 – y yjsj)/2
'logit'	Logística	(–,o)	log[1 + exp(–y yjsj)]/[2log(2)]
'quadratic'	Cuadrática	[0,1]	[1 – y yj(2sj – 1)]2/2

El software normaliza las pérdidas binarias de tal forma que la pérdida es de 0,5 cuando y y_j 0, y agrega utilizando el promedio de los estudiantes binarios .[Allwein et al.]

No confunda la pérdida binaria con la pérdida de clasificación general (especificada por el argumento de par nombre-valor de las funciones y objeto), que mide el rendimiento de un clasificador ECOC en su conjunto.'LossFun'losspredict

Diseño de codificación

A es una matriz donde los elementos dirigen qué clases son entrenadas por cada alumno binario, es decir, cómo el problema multiclase se reduce a una serie de problemas binarios.diseño de codificación

Cada fila del diseño de codificación corresponde a una clase distinta y cada columna corresponde a un alumno binario. En un diseño de codificación ternaria, para una columna determinada (o un alumno binario):

• Una fila que contiene 1 dirige al alumno binario que agrupe todas las observaciones de la clase correspondiente en una clase positiva.

• Una fila que contiene –1 dirige al alumno binario que agrupe todas las observaciones de la clase correspondiente en una clase negativa.

• Una fila que contiene 0 indica al alumno binario que ignore todas las observaciones de la clase correspondiente.

Las matrices de diseño de codificación con distancias de fila grandes, mínimas y en pares basadas en la medida Hamming son óptimas. Para obtener más información sobre la distancia de fila en pares, consulte y .Matrices de diseño de codificación aleatoria[4]

Esta tabla describe los diseños de codificación populares.

Diseño de codificación	Descripción	Número de alumnos	Distancia mínima de fila por pares
uno contra todos (OVA)	Para cada alumno binario, una clase es positiva y el resto son negativos. Este diseño agota todas las combinaciones de asignaciones de clases positivas.	K	2
uno contra uno (OVO)	Para cada alumno binario, una clase es positiva, otra es negativa y el resto se omite. Este diseño agota todas las combinaciones de asignaciones de pares de clases.	( – 1)/2KK	1
binario completo	Este diseño divide las clases en todas las combinaciones binarias y no omite ninguna clase. Es decir, todas las asignaciones de clase son y con al menos una clase positiva y una clase negativa en la asignación para cada alumno binario.–11	2K – 1 – 1	2K – 2
ternario completo	Este diseño divide las clases en todas las combinaciones ternarias. Es decir, todas las asignaciones de clase son , , y con al menos una clase positiva y una clase negativa en la asignación para cada alumno binario.0–11	(3K – 2K + 1 + 1)/2	3K – 2
Ordinal	Para el primer alumno binario, la primera clase es negativa y el resto son positivos. Para el segundo alumno binario, las dos primeras clases son negativas y el resto son positivos, y así sucesivamente.	– 1K	1
denso al azar	Para cada alumno binario, el software asigna clases aleatoriamente en clases positivas o negativas, con al menos uno de cada tipo. Para obtener más información, consulte .Matrices de diseño de codificación aleatoria	Aleatorio, pero aproximadamente 10 registros2K	Variable
escaso al azar	Para cada alumno binario, el software asigna aleatoriamente clases como positivas o negativas con probabilidad 0,25 para cada uno, e ignora las clases con probabilidad 0,5. Para obtener más información, consulte .Matrices de diseño de codificación aleatoria	Aleatorio, pero aproximadamente 15 registros2K	Variable

Esta gráfica compara el número de estudiantes binarios para los diseños de codificación con el aumento de archivos .K

Modelo de códigos de salida de corrección de errores

Un reduce el problema de la clasificación con tres o más clases a un conjunto de problemas de clasificación binaria.modelo de códigos de salida de corrección de errores (ECOC)

La clasificación ECOC requiere un diseño de codificación, que determina las clases en las que se entrenan los alumnos binarios, y un esquema de decodificación, que determina cómo se agregan los resultados (predicciones) de los clasificadores binarios.

Supongamos lo siguiente:

• El problema de clasificación tiene tres clases.

• El diseño de codificación es uno contra uno. Para tres clases, este diseño de codificación es

  $$\begin{array}{cccc}& \text{Learner 1}& \text{Learner 2}& \text{Learner 3}\\ \text{Class 1}& 1& 1& 0\\ \text{Class 2}& -1& 0& 1\\ \text{Class 3}& 0& -1& -1\end{array}$$

• El esquema de decodificación utiliza la pérdida .g

• Los alumnos son SMs.

Para crear este modelo de clasificación, el algoritmo ECOC sigue estos pasos.

1. El alumno 1 entrena en observaciones en la clase 1 o la clase 2, y trata la clase 1 como la clase positiva y la clase 2 como la clase negativa. Los otros estudiantes son entrenados de manera similar.

2. Sea la matriz de diseño de codificación con elementosM M_klY s_l ser la puntuación de clasificación prevista para la clase positiva del alumno.l El algoritmo asigna una nueva observación a la clase ($$\widehat{k}$$) que minimiza la agregación de las pérdidas para los alumnos binarios.L

   $$\widehat{k}=\underset{k}{\text{argmin}}\frac{{\displaystyle \sum }_{l=1}^L\left|m_{kl}\right|g\left(m_{kl},s_l\right)}{{\displaystyle \sum }_{l=1}^L\left|m_{kl}\right|}.$$

Los modelos ECOC pueden mejorar la precisión de clasificación, en comparación con otros modelos multiclase.[2]

Sugerencias

• El número de estudiantes binarios crece con el número de clases. Para un problema con muchas clases, los diseños de codificación y no son eficientes.binarycompleteternarycomplete Sin embargo:

  • Si es 4, utilice el diseño de codificación en lugar de .Kternarycompletesparserandom

  • Si es 5, utilice el diseño de codificación en lugar de .Kbinarycompletedenserandom

  Puede visualizar la matriz de diseño de codificación de un clasificador ECOC entrenado introduciendo en la ventana de comandos.Mdl.CodingMatrix

• Debe formar una matriz de codificación utilizando un conocimiento íntimo de la aplicación y teniendo en cuenta las restricciones computacionales. Si tiene suficiente potencia y tiempo computacional, pruebe varias matrices de codificación y elija la que tenga el mejor rendimiento (por ejemplo, compruebe las matrices de confusión para cada modelo utilizando ).confusionchart

• La validación cruzada de dejar un solo out ( ) es ineficiente para conjuntos de datos con muchas observaciones.Leaveout En su lugar, utilice -fold cross-validation ( ).kKFold

• Después de entrenar un modelo, puede generar código C/C++ que predice las etiquetas para los nuevos datos. La generación de código C/C++ requiere MATLAB Coder™. Para obtener más información, consulte .Introduction to Code Generation

Algoritmos

Matrices de diseño de codificación personalizadas

Las matrices de codificación personalizadas deben tener una forma determinada. El software valida matrices de codificación personalizadas garantizando:

• Cada elemento es -1, 0 o 1.

• Cada columna contiene al menos uno -1 y uno 1.

• Para todos los vectores de columna distintos y , , y - .uvuvuv

• Todos los vectores de filas son únicos.

• La matriz puede separar dos clases cualquiera. Es decir, puede viajar de cualquier fila a cualquier otra fila siguiendo estas reglas:

  • Puede moverse verticalmente de 1 a -1 o -1 a 1.

  • Puede mover horizontalmente de un elemento distinto de cero a otro elemento distinto de cero.

  • Puede utilizar una columna de la matriz para un movimiento vertical solo una vez.

  Si no es posible pasar de una fila a una fila con estas reglas, las clases y no se pueden separar por el diseño.ijij Por ejemplo, en el diseño de codificación

  $$\left[\begin{array}{cc}1& 0\\ -1& 0\\ 0& 1\\ 0& -1\end{array}\right]$$

  las clases 1 y 2 no se pueden separar de las clases 3 y 4 (es decir, no se puede mover horizontalmente del -1 en la fila 2 a la columna 2, ya que hay un 0 en esa posición). Por lo tanto, el software rechaza este diseño de codificación.

Computación paralela

Si utiliza la informática paralela (consulte ), entrena a los alumnos binarios en paralelo.Optionsfitcecoc

Probabilidades y costos anteriores

• Probabilidades anteriores : el software normaliza las probabilidades anteriores de clase especificadas ( ) para cada alumno binario.Prior Sea la matriz de diseño de codificación y ( , ) sea una matriz de indicadores. MIAc La matriz del indicador tiene las mismas dimensiones que .A Si el elemento correspondiente de es , entonces la matriz del indicador tiene elementos iguales a uno, y cero en caso contrario.Ac DejarM₊₁ YM_-1 ser -por- matrices tales que:KL

  • M₊₁ • ( ,1), en el que se trata de una multiplicación de elementos (es decir, ).MIMMplus = M.*(M == 1) Además, deje mosquenos $$m_l^{(+1)}$$ ser vector de columna delM₊₁.

  • M_-1 - - ( ,-1) (es decir, ).MIMMminus = -M.*(M == -1) Además, deje mosquenos $$m_l^{(-1)}$$ ser vector de columna delM_-1.

  Dejar $${\pi }_l^{+1}=m_l^{(+1)}°\pi$$ Y $${\pi }_l^{-1}=m_l^{(-1)}°\pi$$, donde está el vector de las probabilidades anteriores de clase especificadas ( ).πPrior

  Entonces, las probabilidades anteriores positivas y negativas, de clase escalar para el alumno binario sonl

  $${\widehat{\pi }}_l^{(j)}=\frac{{\Vert {\pi }_l^{(j)}\Vert }_1}{{\Vert {\pi }_l^{(+1)}\Vert }_1+{\Vert {\pi }_l^{(-1)}\Vert }_1},$$

  donde se encuentra el número-1,1o yj $${\Vert a\Vert }_1$$ es la norma de una de .a

• Costo — El software normaliza la matriz de costo por ( ) para cada alumno binario.KKCCost Para el alumno binario, el costo de clasificar una observación de clase negativa en la clase positiva esl

  $$c_l^{-+}={\left({\pi }_l^{(-1)}\right)}^{\top }C{\pi }_l^{(+1)}.$$

  Del mismo modo, el costo de clasificar una observación de clase positiva en la clase negativa es

  $$c_l^{+-}={\left({\pi }_l^{(+1)}\right)}^{\top }C{\pi }_l^{(-1)}.$$

  La matriz de costos para el alumno binario esl

  $$C_l=\left[\begin{array}{cc}0& c_l^{-+}\\ c_l^{+-}& 0\end{array}\right].$$

  Los modelos ECOC se adaptan a los costos de clasificación errónea al incorporarlos con probabilidades anteriores de clase. Si especifica y , el software ajusta las probabilidades anteriores de la clase de la siguiente manera:PriorCost

  $$\begin{array}{l}{\overline{\pi }}_l^{-1}=\frac{c_l^{-+}{\widehat{\pi }}_l^{-1}}{c_l^{-+}{\widehat{\pi }}_l^{-1}+c^{+-}{\widehat{\pi }}_l^{+1}}\\ {\overline{\pi }}_l^{+1}=\frac{c_l^{+-}{\widehat{\pi }}_l^{+1}}{c_l^{-+}{\widehat{\pi }}_l^{-1}+c^{+-}{\widehat{\pi }}_l^{+1}}.\end{array}$$

Matrices de diseño de codificación aleatoria

Para un número determinado de clases, el software genera matrices de diseño de codificación aleatoria de la siguiente manera.K

1. El software genera una de estas matrices:

   1. Denso aleatorio — El software asigna 1 o –1 con la misma probabilidad a cada elemento de la -por-KL_d matriz de diseño de codificación, donde $$L_d\approx \lceil 10{\log }_{2}K\rceil$$.

   2. Sparse random — El software asigna 1 a cada elemento de la -by-KL_s matriz de diseño de codificación con probabilidad 0.25, –1 con probabilidad 0.25, y 0 con probabilidad 0.5, donde $$L_s\approx \lceil 15{\log }_{2}K\rceil$$.

2. Si una columna no contiene al menos uno 1 y al menos uno –1, el software elimina esa columna.

3. Para columnas distintas y , if o , , el software se elimina de la matriz de diseño de codificación.uvuvuvv

El software genera aleatoriamente 10.000 matrices de forma predeterminada, y conserva la matriz con la distancia de fila más grande, mínima y por pares basada en la medida Hamming ( ) dada por[4]

$$\Delta (k_1,k_2)=0.5{\displaystyle \sum }_{l=1}^L\left|m_{k_{1}l}\right|\left|m_{k_{2}l}\right|\left|m_{k_{1}l}-m_{k_{2}l}\right|,$$

Dónde M_kjl es un elemento de la matriz de diseño de codificación.j

Soporte de almacenamiento vectorial

De forma predeterminada y por eficiencia, vacía las propiedades , , y para todos los alumnos binarios SVM lineales. listas , en lugar de , en la visualización del modelo.fitcecocAlphaSupportVectorLabelsSupportVectorsfitcecocBetaAlpha

Para almacenar , , y , pasar una plantilla SVM lineal que especifica el almacenamiento de vectores de soporte a .AlphaSupportVectorLabelsSupportVectorsfitcecoc Por ejemplo, escriba:

t = templateSVM('SaveSupportVectors',true) Mdl = fitcecoc(X,Y,'Learners',t);

Puede eliminar los vectores de soporte y los valores relacionados pasando el modelo resultante a .ClassificationECOCdiscardSupportVectors

Referencias

[1] Allwein, E., R. Schapire, and Y. Singer. “Reducing multiclass to binary: A unifying approach for margin classifiers.” Journal of Machine Learning Research. Vol. 1, 2000, pp. 113–141.

[2] Fürnkranz, Johannes, “Round Robin Classification.” J. Mach. Learn. Res., Vol. 2, 2002, pp. 721–747.

[3] Escalera, S., O. Pujol, and P. Radeva. “On the decoding process in ternary error-correcting output codes.” IEEE Transactions on Pattern Analysis and Machine Intelligence. Vol. 32, Issue 7, 2010, pp. 120–134.

[4] Escalera, S., O. Pujol, and P. Radeva. “Separability of ternary codes for sparse designs of error-correcting output codes.” Pattern Recog. Lett., Vol. 30, Issue 3, 2009, pp. 285–297.

Capacidades ampliadas

Arreglos altos

Realice cálculos con arreglos que tienen más filas de las que caben en la memoria.

Notas de uso y limitaciones:

• Las sintaxis admitidas son:

  • Mdl = fitcecoc(X,Y)

  • Mdl = fitcecoc(X,Y,Name,Value)

  • : devuelve los argumentos de salida adicionales y, al especificar el argumento de par nombre-valor.[Mdl,FitInfo,HyperparameterOptimizationResults] = fitcecoc(X,Y,Name,Value)fitcecocFitInfoHyperparameterOptimizationResults'OptimizeHyperparameters'

• El argumento de salida es una matriz de estructura vacía actualmente reservada para un posible uso futuro.FitInfo

• No se admiten opciones relacionadas con la validación cruzada. Los argumentos de par nombre-valor admitidos son:

  • 'ClassNames'

  • 'Cost'

  • — El valor predeterminado es .'Coding''onevsall'

  • — Para la validación cruzada, la optimización alta solo admite la validación.'HyperparameterOptimizationOptions''Holdout' Por ejemplo, puede especificar .fitcecoc(X,Y,'OptimizeHyperparameters','auto','HyperparameterOptimizationOptions',struct('Holdout',0.2))

  • — El valor predeterminado es .'Learners''linear' Puede especificar , , a u objeto, o una matriz de celdas de dichos objetos.'linear''kernel'templateLineartemplateKernel

  • — Cuando se utilizan alumnos binarios lineales, el valor del hiperparámetro debe ser .'OptimizeHyperparameters''Regularization''ridge'

  • 'Prior'

  • — El valor predeterminado es .'Verbose'1

  • 'Weights'

• Este argumento de par nombre-valor adicional es específico de matrices altas:

  • — Un escalar entero positivo que especifica el número de alumnos binarios que se entrenan simultáneamente mediante la combinación de operaciones de E/S de archivos.'NumConcurrent' El valor predeterminado para es , lo que significa que entrena a los alumnos binarios secuencialmente. es más beneficioso cuando las matrices de entrada no caben en la memoria del clúster distribuido.'NumConcurrent'1fitcecoc'NumConcurrent' De lo contrario, las matrices de entrada se pueden almacenar en caché y la aceleración es insignificante.

    Si ejecuta el código en , está limitado por la memoria disponible para las comunicaciones.Apache Spark™NumConcurrent Compruebe las propiedades y en la configuración.'spark.executor.memory''spark.driver.memory'Apache Spark Consulte para obtener más detalles.parallel.cluster.Hadoop (Parallel Computing Toolbox) Para obtener más información sobre y otros entornos de ejecución que controlan dónde se ejecuta el código, vea .Apache SparkExtend Tall Arrays with Other Products

Para obtener más información, consulte .Arreglos altos

Soporte paralelo automático

Acelere código mediante la ejecución automática de cálculo paralelo mediante Parallel Computing Toolbox™.

Para ejecutar en paralelo, establezca la opción en una de estas maneras:'UseParallel'true

• Establezca el campo de la estructura de opciones en using y especifique el argumento de par nombre-valor en la llamada a .'UseParallel'truestatset'Options'fitceoc

  Por ejemplo:'Options',statset('UseParallel',true)

  Para obtener más información, consulte el argumento de par nombre-valor.'Options'

• Realice la optimización de hiperparámetros paralelos mediante el argumento de par nombre-valor en la llamada a .'HyperparameterOptions',struct('UseParallel',true)fitceoc

  Para obtener más información sobre la optimización de hiperparámetros paralelos, consulte .Parallel Bayesian Optimization

Consulte también

ClassificationECOC | ClassificationPartitionedECOC | ClassificationPartitionedKernelECOC | ClassificationPartitionedLinearECOC | CompactClassificationECOC | designecoc | loss | predict | statset

Temas

• Quick Start Parallel Computing for Statistics and Machine Learning Toolbox
• Reproducibility in Parallel Statistical Computations
• Concepts of Parallel Computing in Statistics and Machine Learning Toolbox

Introducido en R2014b

×

Abrir ejemplo

Existe una versión modificada de este ejemplo en su sistema. ¿Prefiere abrir esta versión?

No, sobrescribir la versión modificada Sí