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

Ajuste modelos multiclase para máquinas de vectores de soporte u otros clasificadores

Descripción

Mdl = fitcecoc(Tbl,ResponseVarName) Devuelve un completo, entrenado, multiclase, utilizando los predictores en la tabla y las etiquetas de clase en. utiliza (– 1)/2 modelos de máquina de vectores de soporte binario (SVM) utilizando el uno contra uno, donde es 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 en uso para el entrenamiento.TblFórmulaTbl

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

ejemplo

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

ejemplo

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 la validación cruzada. Es recomendable realizar una validación cruzada mediante el argumento Pair.KfoldName,Value Los resultados de 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 al especificar el argumento de par nombre-valor y utilizar los alumnos binarios lineales o de kernel.OptimizeHyperparameters Para otros, la propiedad de contiene los resultados.LearnersHyperparameterOptimizationResultsMdl

Ejemplos

contraer todo

Entrenar un modelo de códigos de salida de corrección de errores multiclase (ECOC) utilizando estudiantes binarios de la máquina de vectores 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;

Entrenar 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, usa los alumnos binarios de 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 rinde tres estudiantes binarios. Las columnas de corresponden a los alumnos y las filas corresponden a las clases.CodingMat El orden de la clase es el mismo que el orden en.Mdl.ClassNames Por ejemplo, es e indica que el software entrena al primer aprendiz binario de SVM utilizando todas las observaciones clasificadas como y.CodingMat(:,1)[1; –1; 0]'setosa''versicolor' Porque corresponde a, es la clase positiva; corresponde, 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  

Calcule el error de clasificación de reenvío.

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 en cruz el clasificador mediante y calcular el error de clasificación de validación cruzada en su lugar.crossval

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

Cargue el conjunto de datos NLP.

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.Argumentos de par nombre-valortemplateLinear

Entrenar un modelo ECOC compuesto por múltiples modelos de clasificación binaria y lineal que pueden identificar el producto dada la distribución de frecuencias de las palabras en una página web de documentación. Para un tiempo de entrenamiento más rápido, transponer los datos del predictor y especificar que las observaciones corresponden a las 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  

Alternativamente, puede entrenar un modelo ECOC compuesto por modelos de clasificación lineal por defecto utilizando.'Learners','Linear'

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

Valide de forma cruzada un clasificador ECOC con los alumnos binarios de SVM y estime el error de clasificación generalizado.

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

Entrenar el clasificador ECOC y especificar el orden de la clase.

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

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

Valide mediante validación cruzada con 10 veces.Mdl

CVMdl = crossval(Mdl);

es un clasificador ECOC con validación cruzada.CVMdlClassificationPartitionedECOC

Calcule el error de clasificación generalizada.

genError = kfoldLoss(CVMdl)
genError = 0.0400 

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

Entrenar un clasificador ECOC utilizando los estudiantes binarios SVM. Primero predecir las etiquetas de muestra de entrenamiento y las probabilidades posteriores de clase. A continuación, predecir la probabilidad máxima de clase posterior en cada punto de una cuadrícula. Visualiza los resultados.

Cargue el conjunto de datos de iris de Fisher. Especifique las cotas del pétalo 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 de SVM. Estandarice los predictores y especifique el kernel gaussiano.

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

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

Entrenar 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.PredecirresubPredict'FitPosterior' Especifique el orden de la clase mediante el argumento de 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 celdas de plantillas.

Predecir las etiquetas de muestra de entrenamiento y las probabilidades posteriores de clase. Mostrar mensajes de diagnóstico durante el cálculo de las etiquetas y las 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. Debido a que todos los estudiantes binarios están calculando probabilidades posteriores, la función de pérdida binaria es.quadratic

Muestra 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.0039321     0.0039869       0.99208
    'virginica'     'virginica'       0.017067      0.018263       0.96467
    'virginica'     'virginica'       0.014948      0.015856        0.9692
    'versicolor'    'versicolor'    2.2197e-14       0.87317       0.12683
    'setosa'        'setosa'             0.999    0.00025091    0.00074639
    'versicolor'    'virginica'     2.2195e-14      0.059429       0.94057
    'versicolor'    'versicolor'    2.2194e-14       0.97001      0.029986
    'setosa'        'setosa'             0.999     0.0002499    0.00074741
    'versicolor'    'versicolor'     0.0085646       0.98259      0.008849
    'setosa'        'setosa'             0.999    0.00025013    0.00074718

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

Defina una rejilla de valores en el espacio pronosticador observado. Predecir las probabilidades posteriores para cada instancia en 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 de la clase máxima 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

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

Cargue 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, solo 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

Entrena uno contra todos clasificador ECOC

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 utiliza divisiones sustitutas 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 los rellena con sus valores predeterminados durante el entrenamiento.

Entrena un clasificador ECOC de uno contra todos usando los conjuntos de árboles de decisión como estudiantes binarios. Para acelerar el entrenamiento, utilice el binning y la computación paralela.

  • Binning (): cuando tiene un conjunto de datos de entrenamiento grande, puede acelerar el entrenamiento (una disminución potencial en la precisión) mediante el argumento de par nombre-valor.'NumBins',50'NumBins' Este argumento sólo es válido cuando se utiliza un aprendiz de árbol.fitcecoc Si especifica el valor, las ubicaciones de software 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' Usted puede probar primero, y luego cambiar el valor dependiendo de la precisión y la velocidad de entrenamiento.'NumBins',50'NumBins'

  • Parallel Computing (): con una licencia de Parallel Computing Toolbox, puede acelerar el cálculo mediante el uso de la computación paralela, que envía cada alumno binario a un trabajador en el 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 los alumnos binarios, se paraleliza el entrenamiento mediante los bloques de creación de subprocesos de Intel® (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 = 13 es el número de clases distintas.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 en cruz el clasificador ECOC utilizando la 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 se representan mientras que el software entrena por lo 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 para predecir 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 aparezcan 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 datos de predictor en bin 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 de ubicación, que van desde 1 hasta el número de bins, para los predictores numéricos. valores son para los predictores categóricos.XbinnedXbinned0 Si contiene s, los valores correspondientes son s.XNaNXbinnedNaN

Optimice los hiperparámetros automáticamente mediante.fitcecoc

Cargue el conjunto de datos.fisheriris

load fisheriris X = meas; Y = species;

Encuentre hiperparámetros que minimicen la pérdida de validación cruzada de 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 |       1.022 |     0.10667 |     0.10667 |     onevsone |       5.6939 |       200.36 | |    2 | Best   |        0.08 |       6.271 |        0.08 |    0.081379 |     onevsone |       94.849 |    0.0032549 | |    3 | Accept |        0.08 |     0.80629 |        0.08 |     0.08003 |     onevsall |      0.01378 |     0.076021 | |    4 | Accept |        0.08 |     0.56414 |        0.08 |    0.080001 |     onevsall |          889 |       38.798 | |    5 | Best   |    0.073333 |      0.7598 |    0.073333 |    0.073337 |     onevsall |       17.142 |       1.7174 | |    6 | Accept |        0.26 |      27.832 |    0.073333 |    0.073337 |     onevsall |      0.88995 |    0.0010029 | |    7 | Accept |        0.08 |     0.60666 |    0.073333 |    0.073341 |     onevsall |      0.23012 |      0.34633 | |    8 | Best   |        0.04 |       1.038 |        0.04 |    0.040007 |     onevsone |       100.53 |      0.10211 | |    9 | Accept |     0.12667 |     0.42839 |        0.04 |     0.04001 |     onevsone |    0.0015155 |      0.91412 | |   10 | Accept |    0.046667 |      5.2866 |        0.04 |    0.040017 |     onevsone |       931.08 |     0.040024 | |   11 | Accept |        0.04 |     0.67289 |        0.04 |    0.040003 |     onevsone |       965.69 |      0.36688 | |   12 | Accept |     0.33333 |     0.51732 |        0.04 |    0.040005 |     onevsall |    0.0010224 |       17.726 | |   13 | Accept |    0.046667 |      19.453 |        0.04 |    0.040003 |     onevsall |       892.53 |      0.35788 | |   14 | Accept |    0.046667 |     0.66214 |        0.04 |    0.039989 |     onevsone |       963.47 |       6.6814 | |   15 | Accept |        0.04 |     0.72669 |        0.04 |     0.03999 |     onevsone |    0.0010354 |    0.0010571 | |   16 | Accept |    0.046667 |     0.52203 |        0.04 |    0.039987 |     onevsone |    0.0011208 |    0.0078247 | |   17 | Accept |        0.04 |      1.4773 |        0.04 |    0.039982 |     onevsall |       916.38 |        1.868 | |   18 | Accept |     0.10667 |     0.64654 |        0.04 |    0.039982 |     onevsone |       993.53 |       989.56 | |   19 | Accept |        0.04 |     0.40883 |        0.04 |    0.039981 |     onevsone |     0.028541 |    0.0037104 | |   20 | Accept |        0.04 |     0.42683 |        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.42 |        0.04 |    0.039964 |     onevsone |    0.0011513 |    0.0021711 | |   22 | Accept |    0.046667 |      3.5102 |        0.04 |    0.039792 |     onevsall |       978.75 |       1.0047 | |   23 | Accept |        0.04 |     0.55582 |        0.04 |     0.03979 |     onevsone |       965.54 |       1.0173 | |   24 | Accept |        0.04 |     0.78557 |        0.04 |    0.039801 |     onevsone |       11.578 |     0.048162 | |   25 | Accept |    0.046667 |      0.7299 |        0.04 |    0.039603 |     onevsone |       909.35 |       0.1889 | |   26 | Accept |        0.04 |     0.63815 |        0.04 |    0.039541 |     onevsone |       82.422 |      0.81772 | |   27 | Accept |        0.04 |     0.41874 |        0.04 |    0.039528 |     onevsone |     0.061877 |    0.0080194 | |   28 | Accept |        0.04 |     0.58331 |        0.04 |    0.039658 |     onevsone |    0.0050147 |    0.0026878 | |   29 | Accept |        0.04 |     0.47419 |        0.04 |    0.039677 |     onevsone |       526.28 |       1.2964 | |   30 | Accept |        0.04 |     0.67384 |        0.04 |    0.039693 |     onevsall |       945.22 |        4.473 |  __________________________________________________________ Optimization completed. MaxObjectiveEvaluations of 30 reached. Total function evaluations: 30 Total elapsed time: 148.5544 seconds. Total objective function evaluation time: 78.9175  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.038  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.49296 
Mdl =    ClassificationECOC                          ResponseName: 'Y'                 CategoricalPredictors: []                            ClassNames: {'setosa'  'versicolor'  'virginica'}                        ScoreTransform: 'none'                        BinaryLearners: {3x1 cell}                            CodingName: 'onevsone'     HyperparameterOptimizationResults: [1x1 BayesianOptimization]     Properties, Methods  

Cree dos modelos de ECOC multiclase formados en datos altos. Utilice los alumnos binarios lineales para uno de los modelos y los alumnos binarios del kernel para el otro. Compare el error de la clasificación de reenvío de los dos modelos.

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

Cree un almacén de datos que hace referencia a la carpeta que contiene el conjunto de archivos iris de Fisher. Especifique los valores como datos faltantes para que los sustituya por valores.'NA'datastoreNaN Cree versiones altas de los datos de predicción 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 predictores.

Z = zscore(X);

Entrenar un modelo ECOC multiclase que utiliza datos altos y estudiantes binarios lineales. Por abandono, cuando usted pasa las matrices altas a, el software entrena los estudiantes binarios lineales que utilizan los SVC.fitcecoc Dado que los datos de respuesta contienen solo tres clases únicas, cambie el esquema de codificación de uno contra todos (que es el valor predeterminado cuando se usan datos altos) a uno contra uno (que es el valor predeterminado cuando se usan datos en memoria).

Para reproducibilidad, establezca las semillas de los generadores de números aleatorios utilizando y.rngtallrng Los resultados pueden variar en función del número de trabajadores y del entorno de ejecución de los arrays altos. Para obtener más información, consulte.Controle dónde se ejecuta el código (MATLAB)

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

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

<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 la clasificación de reenvío 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.8 sec Evaluation completed in 1.9 sec 
errorLinear = 0.0333 
errorKernel = gather(loss(mdlKernel,Z,Y))
Evaluating tall expression using the Parallel Pool 'local': - Pass 1 of 1: Completed in 18 sec Evaluation completed in 18 sec 
errorKernel = 0.0067 

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

Argumentos de entrada

contraer todo

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 ni matrices de celdas que no sean 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 entrenar modelos de clasificación de kernel o lineales, no admite tablas.fitcecoc Es decir, si es o, contiene una plantilla de aprendizaje de modelo de clasificación lineal (consulte), o contiene una plantilla de aprendizaje de clasificación de kernel (consulte), no puede suministrar, 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

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

Debe especificar como un vector de caracteres o un escalar de cadena.ResponseVarName Por ejemplo, si la variable de respuesta se almacena como, a continuación, especifíquese 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 caracteres o de cadena, un vector lógico o numérico o una matriz 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

Es una buena práctica para especificar el orden de las clases mediante el argumento de par nombre-valor.ClassNames

Tipos de datos: char | string

Modelo explicativo de la respuesta y un subconjunto de las variables predictoras, especificadas como un vector de caracteres o un 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 Las variables deben ser nombres de variable en ().TblTbl.Properties.VariableNames

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 en la que no aparezcan.TblFórmula

Tipos de datos: char | string

Etiquetas de clase a las que se entrena el modelo ECOC, especificadas como una matriz categórica, de caracteres o de cadena, Vector lógico o numérico o 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 deben ser iguales.YTblX

Es recomendable especificar el orden de la clase mediante el argumento de par nombre-valor.ClassNames

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

Datos de 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 las columnas y las especifique, puede experimentar una reducción significativa en el tiempo de ejecución de la optimización.X'ObservationsIn','columns'

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

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

Tipos de datos: double | single

Nota

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

Argumentos de par nombre-valor

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

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

Nota

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

Opciones de clasificador ECOC

contraer todo

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'

ValorNúmero de estudiantes binariosDescripción
Y'allpairs''onevsone'(– 1)/2KKPara 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(K1)1Este diseño divide las clases en todas las combinaciones binarias y no ignora 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 log2KPara cada alumno binario, el software asigna aleatoriamente clases 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'KPara cada alumno binario, una clase es positiva y el resto es negativo. Este diseño agota todas las combinaciones de asignaciones de clase positivas.
'ordinal'– 1KPara el primer aprendizaje binario, la primera clase es negativa y el resto es positivo. Para el segundo aprendizaje binario, las dos primeras clases son negativas, el resto es positivo, y así sucesivamente.
'sparserandom'Aleatorio, pero aproximadamente 15 log2KPara cada alumno binario, el software asigna aleatoriamente clases como positivas o negativas con la probabilidad 0,25 para cada uno, y omite las clases con la probabilidad 0,5. Para obtener más información, consulte.Matrices de diseño de codificación aleatoria
'ternarycomplete'(3K2(K+1)+1)/2Este diseño divide las clases en todas las combinaciones ternarias. Todas las asignaciones de clase son, y con al menos una clase positiva y una 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 a-by-Matrix.KL Cada fila corresponde a una clase y cada columna corresponde a un alumno binario. El orden de la clase (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 dicottóloga.-101 Esta tabla describe el significado de, es decir, la clase que el alumno asigna a las observaciones de la clase.Coding(i,j)ji

    ValorAsignación de clase dicottóloga
    –1El alumno asigna observaciones en clase a una clase negativa.ji
    0Antes del entrenamiento, el alumno elimina las observaciones de la clase del conjunto de datos.ji
    1El 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, tal que ≠, no puede ser igual y no puede ser igual.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 detalles sobre la forma de matrices de diseño de codificación personalizadas, consulte.Matrices de diseño de codificación personalizada

Ejemplo: 'Coding','ternarycomplete'

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

Indicador que indica si se transformarán las puntuaciones en probabilidades posteriores, especificadas como el par separado por comas que consta de y a () o ().'FitPosterior'true1false0

Si es así, el software transforma las puntuaciones de clasificación de los alumnos binarios en probabilidades posteriores.FitPosteriortrue Puede obtener probabilidades posteriores mediante kfoldPredict, predictO resubPredict.

no admite la adaptación de probabilidades posteriores si:fitcecoc

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

  • Los aprendientes binarios () son modelos de clasificación lineal o kernel que implementan SVM.Learners Para obtener probabilidades posteriores de modelos de clasificación de kernel o lineales, implemente la regresión logística en su lugar.

Ejemplo: 'FitPosterior',true

Tipos de datos: logical

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 de varias clases.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 cada alumno binario utilizando los valores predeterminados del algoritmo especificado.Learners Esta tabla resume los algoritmos disponibles.

    ValorDescripción
    'discriminant'Análisis discriminante. Para ver las opciones predeterminadas, consulte.templateDiscriminant
    'kernel'Modelo de clasificación de kernel. 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 Naive. Para ver las opciones predeterminadas, consulte.templateNaiveBayes
    'svm'Svm. Para ver las opciones predeterminadas, consulte.templateSVM
    'tree'Árboles de clasificación. Para ver las opciones predeterminadas, consulte.templateTree

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

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

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

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

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

    • De forma similar, no puede especificar plantillas de aprendizaje de modelo de clasificación de kernel con ninguna otra plantilla.

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

Ejemplo: 'Learners','tree'

Número de bins para predictores numéricos, especificados 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 aprendizaje de árbol, es decir, es o un objeto de plantilla creado mediante el uso, o un objeto de plantilla creado mediante el uso con los estudiantes débiles de árbol.'Learner''tree'templateTreetemplateEnsemble

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

  • Si especifica el valor como un escalar entero positivo, las ubicaciones de software 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 excede el número () de valores únicos para un predictor,'NumBins'u fitcecoc bins el predictor en bins.u

    • fitcecoc no bin predictores categóricos.

Cuando se utiliza un conjunto de datos de entrenamiento de gran tamaño, esta opción de discretización acelera el entrenamiento, pero provoca una posible disminución de la precisión. Usted puede probar primero, y luego cambiar el valor dependiendo 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

Número de alumnos binarios formados simultáneamente, especificados como el par separado por comas que consta de un escalar entero positivo.'NumConcurrent' El valor predeterminado es, lo que significa que entrena 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.Tall arrays

Tipos de datos: single | double

Dimensión de observación de Datos predictores, 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 las columnas y las especifique, puede experimentar una reducción significativa en el tiempo de ejecución de la optimización.X'ObservationsIn','columns'

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

Ejemplo: 'ObservationsIn','columns'

Nivel de verbosidad, especificado como el par separado por comas que consta de y, o. controla la cantidad de información de diagnóstico por cada 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.

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

Cada alumno binario tiene su propio nivel de verbosidad 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 a mediante el argumento de par nombre-valor.fitcecoc'Learners'

Ejemplo: 'Verbose',1

Tipos de datos: double | single

Opciones de validación cruzada

contraer todo

Marcar para entrenar un clasificador con validación cruzada, especificado como el par separado por comas que consta de y o.'Crossval''on''off'

Si se especifica, el software entrena un clasificador de validación cruzada con 10 pliegues.'on'

Puede invalidar esta configuración de validación cruzada mediante uno de los argumentos de par nombre-valor, o Name.CVPartitionHoldoutKFoldLeaveout Sólo se puede utilizar un argumento de par nombre-valor de validación cruzada a la vez para crear un modelo validado de forma cruzada.

Alternativamente, valide de forma cruzada más adelante pasando aMdl crossval.

Ejemplo: 'Crossval','on'

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

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

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

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

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

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

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

Ejemplo: 'Holdout',0.1

Tipos de datos: double | single

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

  1. Particionar aleatoriamente los datos en sets.k

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

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

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

Ejemplo: 'KFold',5

Tipos de datos: single | double

Marca de validación cruzada de Leave-One-out, especificada como el par separado por comas que consta de y o.'Leaveout''on''off' Si especifica, a continuación, para cada una de las observaciones, donde está, el software:'Leaveout','on'nnsize(Mdl.X,1)

  1. Se reserva la observación como datos de validación, y entrena el modelo utilizando el otro – 1 observacionesn

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

Para crear un modelo con validación cruzada, puede utilizar una de estas cuatro opciones solamente:,,, o.CVPartitionHoldoutKFoldLeaveout

Nota

Leave-One-out no se recomienda para los modelos ECOC de validación cruzada compuestos por alumnos de modelo de clasificación lineal o de kernel.

Ejemplo: 'Leaveout','on'

Otras opciones de clasificación

contraer todo

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

ValorDescripción
Vector de enteros positivosUna entrada en el vector es el valor de índice correspondiente a la columna de los Datos predictores (o) que contiene una variable categórica.XTbl
Vector lógicoUna entrada significa que la columna correspondiente de Datos predictores (o) es una variable categórica.trueXTbl
Matriz de caracteresCada fila de la matriz es el nombre de una variable predictora. Los nombres deben coincidir con las entradas.PredictorNames Pad los nombres con espacios en blanco adicionales por lo que cada fila de la matriz de caracteres tiene la misma longitud.
Matriz de cadenas o matriz de vectores de caracteresCada elemento de la matriz es el nombre de una variable predictora. Los nombres deben coincidir con las entradas.PredictorNames
todosTodos los predictores son categóricos.

La especificación es apropiada si:CategoricalPredictors

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

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

Si usted especifica para cualquier otro aprendiz, después el software advierte que no puede entrenar a ese aprendiz binario.CategoricalPredictors Por ejemplo, el software no puede entrenar a los alumnos del modelo de clasificación lineal o kernel utilizando predictores categóricos.

De forma predeterminada, si los Datos predictores están en una tabla (),Tbl fitcecoc asume que una variable es categórica si contiene valores lógicos, valores categóricos, una matriz de cadenas o una matriz de vectores de caracteres. Si los Datos predictores son una matriz (),X fitcecoc asume que todos los predictores son continuos. Para identificar los predictores categóricos cuando los datos son una matriz, utilice el argumento de par nombre-valor.'CategoricalPredictors'

Ejemplo: 'CategoricalPredictors','all'

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

Nombres de las clases que se usarán para el entrenamiento, especificadas como el par separado por comas que consta de una matriz categórica, de caracteres o de cadena, un vector lógico o numérico o una matriz 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.ClassNamesrow

Utilizar para:ClassNames

  • Ordene las clases durante el entrenamiento.

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

  • 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 utilizando observaciones de clases y sólo, 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

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

  • La matriz cuadrada, a continuación, es el costo de clasificar un punto en la clase si su verdadera clase es.CostoCost(i,j)ji Es decir, las filas corresponden a la clase true y las columnas corresponden a la clase pronosticada. Para especificar el orden de la clase de las filas y columnas correspondientes, especifique además el argumento de par nombre-valor.CostoClassNames

  • La estructura, entonces 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

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

Esta tabla resume las opciones disponibles.

OpciónDescripción
'Streams'

Un objeto o matriz de celdas de estos objetos.RandStream Si no se especifica, el software utiliza la secuencia o secuencias predeterminadas.Streams Si especifica, utilice un único objeto excepto cuando se cumplen los siguientes pasos:Streams

  • Tiene una piscina paralela abierta.

  • Es.UseParalleltrue

  • Es.UseSubstreamsfalse

En ese caso, utilice una matriz de celdas del mismo tamaño que el grupo paralelo. Si un pool paralelo no está abierto, después el software intenta abrir uno (dependiendo de sus preferencias), y debe suministrar un solo flujo de números aleatorios.Streams

'UseParallel'

Si lo 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 en el grupo.

Cuando utiliza árboles de decisión para los alumnos binarios, fitcecoc paraleliza el entrenamiento mediante el uso de bloques de creación de subprocesos (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'Se establece en para calcular en paralelo mediante la secuencia especificada por.true'Streams' El valor predeterminado es.false Por ejemplo, establezca 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 computación paralela medianteparpool fitcecoc.

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

Tipos de datos: struct

Los 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 se suministra y, a continuación, se puede utilizar para dar las variables predictoras en los nombres.XY'PredictorNames'X

    • El orden de los nombres en debe corresponder al orden de las columnas de.PredictorNamesX Es decir, es el nombre de, es el nombre de, y así sucesivamente.PredictorNames{1}X(:,1)PredictorNames{2}X(:,2) También, y debe ser igual.size(X,2)numel(PredictorNames)

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

  • Si usted suministra, entonces usted puede utilizar para elegir qué variables predictoras a utilizar en el entrenamiento.Tbl'PredictorNames' Es decir fitcecoc utiliza únicamente las variables predictoras 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 para especificar los predictores para el entrenamiento utilizando cualquiera o sólo.'PredictorNames'Fórmula

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

Tipos de datos: string | cell

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

ValorDescripción
'empirical'Las probabilidades previas de clase son las frecuencias de clase relativas.Y
'uniform'Todas las probabilidades previas de clase son iguales a 1/, donde está el número de clases.KK
Vector numéricoCada elemento es una clase de probabilidad previa. Ordene los elementos según o especifique el orden mediante el argumento de par nombre-valor.Mdl.ClassNamesClassNames El software normaliza los elementos que suman.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 previas correspondientes.S.ClassProbs El software normaliza los elementos que suman.1

Para obtener más detalles sobre cómo el software incorpora probabilidades previas de clase, consulte.Probabilidades previas y costo

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

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

Nombre de 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 usted suministra o, entonces usted no puede utilizar.ResponseVarNameFórmula'ResponseName'

Ejemplo: 'ResponseName','response'

Tipos de datos: char | string

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'

Esta tabla resume los vectores de caracteres disponibles y los escalares de cadena.

ValorDescripción
'doublelogit'1/(1 +e–2x)
'invlogit'log (/(1 –))xx
'ismax'Establece la puntuación de la clase con la puntuación más grande y establece las puntuaciones de todas las demás clases para10
'logit'1/(1 +ex)
O'none''identity'(sin transformación)x
'sign'– 1 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 grande y establece las puntuaciones de todas las demás clases para1–1
'symmetriclogit'2/(1 +ex) – 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

Ponderaciones de observación, especificadas 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 pesa las observaciones en cada fila 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 un vector de caracteres o un escalar de cadena.Weights Por ejemplo, si el vector de ponderaciones se almacena como, a continuación, especifíquese 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 normaliza para resumir 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

La optimización de hiperparámetros

contraer todo

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

  • — No optimice.'none'

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

    • = (por defecto) —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'}

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

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

  • Vector de objetos, normalmente la salida deoptimizableVariablehiperparámetros

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

Nota

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

Los parámetros elegibles para son:fitcecoc

  • — busca entre y.Codingfitcecoc'onevsall''onevsone'

  • Los hiperparámetros elegibles para los elegidos, como se especifica en esta tabla.Learners

    EstudiantesHyperparameters elegibles (negrita = predeterminado)
    Rango predeterminado
    'discriminant'DeltaEscalado logaritmo en el intervalo[1e-6,1e3]
    DiscrimTypeY'linear''quadratic''diagLinear''diagQuadratic''pseudoLinear''pseudoQuadratic'
    GammaValores reales en[0,1]
    'kernel'LambdaLos valores positivos se registran en el intervalo[1e-3/NumObservations,1e3/NumObservations]
    KernelScaleLos valores positivos se registran en el intervalo[1e-3,1e3]
    LearnerY'svm''logistic'
    NumExpansionDimensionsLos enteros registran la escala en el rango[100,10000]
    'knn'DistanceY'cityblock''chebychev''correlation''cosine''euclidean''hamming''jaccard''mahalanobis''minkowski''seuclidean''spearman'
    DistanceWeightY'equal''inverse''squaredinverse'
    ExponentLos valores positivos en[0.5,3]
    NumNeighborsLos valores enteros positivos registran la escala en el intervalo[1, max(2,round(NumObservations/2))]
    StandardizeY'true''false'
    'linear'LambdaLos valores positivos se registran en el intervalo[1e-5/NumObservations,1e5/NumObservations]
    LearnerY'svm''logistic'
    RegularizaciónY'ridge''lasso'
    'naivebayes'DistributionNamesY'normal''kernel'
    WidthLos valores positivos se registran en el intervalo[MinPredictorDiff/4,max(MaxPredictorRange,MinPredictorDiff)]
    NúcleoY'normal''box''epanechnikov''triangle'
    'svm'BoxConstraintLos valores positivos se registran en el intervalo[1e-3,1e3]
    KernelScaleLos valores positivos se registran en el intervalo[1e-3,1e3]
    KernelFunctionY'gaussian''linear''polynomial'
    PolynomialOrderLos enteros en el rango[2,4]
    StandardizeY'true''false'
    'tree'MaxNumSplitsLos enteros registran la escala en el rango[1,max(2,NumObservations-1)]
    MinLeafSizeLos enteros registran la escala en el rango[1,max(2,floor(NumObservations/2))]
    NumVariablesToSampleLos enteros en el rango[1,max(2,NumPredictors)]
    SplitCriterionY'gdi''deviance''twoing'

    Alternativamente, use con su elección, comohiperparámetrosLearners

    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 tienen 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 comandos y los trazados aparecen según el número de hiperparámetros de la optimización. Para la optimización y los trazados, la función objetivo es log(1 + cross-validation loss) para la regresión y la tasa de clasificación errónea para la clasificación. Para controlar la visualización iterativa, establezca el campo del argumento de par nombre-valor.Verbose'HyperparameterOptimizationOptions' Para controlar los trazados, establezca el campo del argumento de par nombre-valor.ShowPlots'HyperparameterOptimizationOptions'

Para ver un ejemplo, vea.Optimice el clasificador ECOC

Ejemplo: 'auto'

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

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

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

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

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

'bayesopt'
AcquisitionFunctionName

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

  • 'expected-improvement'

  • 'expected-improvement-plus'

  • 'expected-improvement-per-second'

  • 'lower-confidence-bound'

  • 'probability-of-improvement'

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

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

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

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

Mostrar en la línea de comandos.

  • — Sin visualización iterativa0

  • — Visualización iterativa1

  • — Visualización iterativa con información adicional2

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

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

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

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

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

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

Tipos de datos: struct

Argumentos de salida

contraer todo

Clasificador de ECOC entrenado, devuelto como un objeto de modelo o un objeto de modelo, o con validación cruzada.ClassificationECOCCompactClassificationECOCClassificationPartitionedECOCClassificationPartitionedLinearECOCClassificationPartitionedKernelECOC

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

Modelo de clasificación lineal estudiantesModelo de clasificación de kernel estudiantesValidación cruzadaObjeto de modelo devuelto
NoNoNoClassificationECOC
NoNoClassificationPartitionedECOC
NoNoCompactClassificationECOC
NoClassificationPartitionedLinearECOC
NoNoCompactClassificationECOC
NoClassificationPartitionedKernelECOC

Descripción de la optimización de validación cruzada de los 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 de kernel.BayesianOptimizationHyperparameterOptimizationResultsOptimizeHyperparametersLearners El valor depende de la configuración del argumento de par nombre-valor:HyperparameterOptimizationOptions

  • (valor predeterminado) — objeto de la clase'bayesopt'BayesianOptimization

  • o — tabla de hiperparámetros utilizados, valores de función objetiva observados (pérdida de validación cruzada) y rango de observación desde el más pequeño (el mejor) al más alto (el peor)'gridsearch''randomsearch'

Tipos de datos: table

Limitaciones

  • Para entrenar modelos de clasificación de kernel o lineales, no admite tablas.fitcecoc Es decir, si es o, contiene una plantilla de aprendizaje de modelo de clasificación lineal (vea), o contiene una plantilla de aprendizaje de modelo de clasificación de kernel (consulte), a continuación, 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, en su lugar, proporcione una matriz completa de Datos predictores.

Más acerca de

contraer todo

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:

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

  • sj es la puntuación de aprendizaje binario para una observación.j

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

  • 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.]

k^=argminkj=1L|mkj|g(mkj,sj).

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

k^=argminkj=1L|mkj|g(mkj,sj)j=1L|mkj|.

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

En esta tabla se resumen las funciones de pérdida admitidas, donde yj es una etiqueta de clase para un alumno binario determinado (en el conjunto {– 1, 1, 0}), sj es la partitura para la observación, y (jgyj,sj).

ValorDescripciónPuntuación de dominio(gyj,sj)
'binodeviance'Desviación binomial(– ∞, ∞)log [1 + exp (– 2yjsj)]/[2log (2)]
'exponential'Exponencial(– ∞, ∞)exp (–yjsj)/2
'hamming'Hamming[0, 1] o (– ∞, ∞)[1 – signo (yjsj)]/2
'hinge'Bisagra(– ∞, ∞)Max (0,1 – yjsj)/2
'linear'Lineal(– ∞, ∞)1 yjsj)/2
'logit'Logística(– ∞, ∞)log [1 + exp (–yjsj)]/[2log (2)]
'quadratic'Cuadrática[0,1]1 yj(2sj – 1)]2/2

El software normaliza las pérdidas binarias de tal forma que la pérdida es de 0,5 cuando yj = 0 y agregados con el promedio de los alumnos 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 de objeto y), que mide qué tan bien se comporta un clasificador ECOC como un todo.'LossFun'lossPredecir

Diseño de codificación

A es una matriz donde los elementos dirigen qué clases son entrenadas por cada aprendiz 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 en particular (o aprendizaje binario):

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

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

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

Las matrices de diseño de codificación con distancias de fila grandes, mínimas y en parejas basadas en la medida de 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ónDescripciónNúmero de alumnos Distancia mínima de fila en parejas
uno contra todos (OVA)Para cada alumno binario, una clase es positiva y el resto es negativo. Este diseño agota todas las combinaciones de asignaciones de clase positivas.K2
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 ignora 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 – 12K – 2
ternarios completos

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
OrdinalPara el primer aprendizaje binario, la primera clase es negativa y el resto es positivo. Para el segundo aprendizaje binario, las dos primeras clases son negativas y el resto son positivas, y así sucesivamente.– 1K1
aleatoria densaPara cada alumno binario, el software asigna aleatoriamente clases 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 log2K

Variable
aleatorio dispersoPara cada alumno binario, el software asigna aleatoriamente clases como positivas o negativas con la probabilidad 0,25 para cada uno, y omite las clases con la probabilidad 0,5. Para obtener más información, consulte.Matrices de diseño de codificación aleatoria

Aleatorio, pero aproximadamente 15 log2K

Variable

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

Códigos de salida de corrección de errores modelo

A reduce el problema de 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 entrena el aprendizaje binario y un esquema de decodificación, que determina cómo se agregan los resultados (predicciones) de los clasificadores binarios.

Suponga 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

    Learner 1Learner 2Learner 3Class 1110Class 2101Class 3011

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

  • Los alumnos son SVMs.

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

  1. El aprendiz 1 entrena en observaciones de clase 1 o clase 2, y trata la clase 1 como la clase positiva y la clase 2 como clase negativa. Los otros alumnos se entrenan de manera similar.

  2. Seamos la matriz de diseño de codificación con elementosM MklY sl ser la puntuación de clasificación pronosticada para la clase positiva del alumno.l El algoritmo asigna una nueva observación a la clase (k^) que minimiza la agregación de las pérdidas para los estudiantes binarios.L

    k^=argminkl=1L|mkl|g(mkl,sl)l=1L|mkl|.

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

Sugerencias

  • El número de alumnos 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 ≤ 4, a continuación, utilizar el diseño de codificación en lugar de.Kternarycompletesparserandom

    • Si ≤ 5, a continuación, utilizar 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 entrando 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 computacional y tiempo, pruebe varias matrices de codificación y elija la que tenga el mejor rendimiento (p. ej., compruebe las matrices de confusión para cada modelo usando).confusionchart

  • La validación cruzada de salida única () no es eficaz para conjuntos de datos con muchas observaciones.Leaveout En su lugar, use-Fold Cross-Validation ().kKFold

  • Después de entrenar un modelo, puede generar código de C/C++ que predice etiquetas para nuevos datos. La generación de código C/C++ requiere MATLABCoder™. Para obtener más información, consulte.Introducción a la generación de código

Algoritmos

contraer todo

Matrices de diseño de codificación personalizada

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

  • Cada elemento es-1, 0 o 1.

  • Cada columna contiene como mínimo uno-1 y un 1.

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

  • Todos los vectores de filas son únicos.

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

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

    • Puede desplazarse horizontalmente desde un elemento distinto de cero a otro elemento distinto de cero.

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

    Si no es posible pasar de una fila a la fila usando estas reglas, entonces las clases y no pueden ser separadas por el diseño.ijij Por ejemplo, en el diseño de codificación

    [10100101]

    las clases 1 y 2 no se pueden separar de las clases 3 y 4 (es decir, no se puede desplazar horizontalmente de la-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 computación paralela (ver), entonces entrena a los estudiantes binarios en paralelo.Optionsfitcecoc

Probabilidades previas y costo

  • Probabilidades previas — el software normaliza las probabilidades previas de la clase especificada () para cada aprendiz binario.Prior Seamos la matriz de diseño de codificación y (,) ser una matriz indicadora. MIAc La matriz indicadora tiene las mismas dimensiones que.A Si el elemento correspondiente de es, entonces la matriz del indicador tiene elementos que equivalen a uno, y cero de lo contrario.Ac DejarM+1 YM-1 ser-por-matrices tales que:KL

    • M+1 = ○ (, 1), donde ○ es la multiplicación de elementos-Wise (es decir,).MIMMplus = M.*(M == 1) Además, deja que ml(+1) ser vector de columna delM+1.

    • M-1 =-○ (,-1) (es decir,).MIMMminus = -M.*(M == -1) Además, deja que ml(1) ser vector de columna delM-1.

    Dejar πl+1=ml(+1)°π Y πl1=ml(1)°π, donde está el vector de las probabilidades previas especificadas de la clase ().πPrior

    A continuación, las probabilidades anteriores de clase escalar positiva y negativa para el aprendizaje binario sonl

    π^l(j)=πl(j)1πl(+1)1+πl(1)1,

    donde = {-1, 1} yj a1 es una norma de.a

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

    cl+=(πl(1))Cπl(+1).

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

    cl+=(πl(+1))Cπl(1).

    La matriz de costes para el aprendizaje binario esl

    Cl=[0cl+cl+0].

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

    π¯l1=cl+π^l1cl+π^l1+c+π^l+1π¯l+1=cl+π^l+1cl+π^l1+c+π^l+1.

Matrices de diseño de codificación aleatoria

Para un número dado 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. Aleatorio denso: el software asigna 1 o – 1 con la misma probabilidad a cada elemento de-por-KLd matriz de diseño de codificación, donde Ld10log2K.

    2. Aleatorio disperso: el software asigna 1 a cada elemento de-por-KLs matriz de diseño de codificación con probabilidad 0,25, – 1 con probabilidad 0,25, y 0 con probabilidad 0,5, donde Ls15log2K.

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

  3. Para las columnas distintas y, si = o = –, el software elimina de la matriz de diseño de codificación.uvuvuvv

El software genera aleatoriamente 10.000 matrices por defecto, y retiene la matriz con la mayor, mínima, distancia de fila en pares basada en la medida de Hamming () dada por[4]

Δ(k1,k2)=0.5l=1L|mk1l||mk2l||mk1lmk2l|,

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

Soporte de almacenamiento vectorial

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

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

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

Puede quitar 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

Introducido en R2014b