fitcecoc
Ajustar modelos multiclase para máquinas vectoriales de soporte u otros clasificadores
Sintaxis
Descripción
Mdl = fitcecoc(Tbl,ResponseVarName)TblTbl.ResponseVarNamefitcecocKKdiseño de codificaciónKMdlClassificationECOC
Mdl = fitcecoc(___,Name,Value)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.
[
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.Mdl,HyperparameterOptimizationResults]
= fitcecoc(___,Name,Value)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 learnerans = 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 nlpdataes 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.fitcecocSi 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.fitcecocPor 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; endcontiene 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
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
Argumentos de salida
Limitaciones
Para el entrenamiento de modelos de clasificación lineal o de kernel, no admite tablas.
fitcecocEs 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órmulaProporcione una matriz de datos predictores ( ) y una matriz de respuestas ( ) en su lugar.XYfitcecocadmite 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
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. | 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. | (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
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.
binarycompleteternarycompleteSin embargo:Si es 4, utilice el diseño de codificación en lugar de .K
ternarycompletesparserandomSi es 5, utilice el diseño de codificación en lugar de .K
binarycompletedenserandom
Puede visualizar la matriz de diseño de codificación de un clasificador ECOC entrenado introduciendo en la ventana de comandos.
Mdl.CodingMatrixDebe 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 ).
confusionchartLa validación cruzada de dejar un solo out ( ) es ineficiente para conjuntos de datos con muchas observaciones.
LeaveoutEn 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
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
Consulte también
ClassificationECOC | ClassificationPartitionedECOC | ClassificationPartitionedKernelECOC | ClassificationPartitionedLinearECOC | CompactClassificationECOC | designecoc | loss | predict | statset
Select a Web Site
Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .
Select web siteYou can also select a web site from the following list:
Americas
- América Latina (Español)
- Canada (English)
- United States (English)
Europe
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)
