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.
Ajustar modelos multiclase para máquinas vectoriales de soporte u otros clasificadores
devuelve un completo, entrenado, multiclase, utilizando los predictores de la tabla y las etiquetas de clase en . utiliza ( – 1)/2 modelos de máquina vectorial de soporte binario (SVM) utilizando el uno contra uno , donde está el número de etiquetas de clase únicas (niveles). es un modelo.modelo de códigos de salida de corrección de errores (ECOC)Mdl
= fitcecoc(Tbl
,ResponseVarName
)Tbl
Tbl.ResponseVarName
fitcecoc
KKdiseño de codificaciónKMdl
ClassificationECOC
devuelve un modelo ECOC con opciones adicionales especificadas por uno o más argumentos de par, utilizando cualquiera de las sintaxis anteriores.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.Kfold
Name,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.Learners
HyperparameterOptimizationResults
Mdl
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.X
Y
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.Mdl
ClassificationECOC
De forma predeterminada, utiliza los alumnos binarios SVM y un diseño de codificación uno contra uno.fitcecoc
Puede acceder a las propiedades mediante la notación de puntos.Mdl
Mostrar los nombres de clase y la matriz de diseño de codificación.
Mdl.ClassNames
ans = 3x1 cell array
{'setosa' }
{'versicolor'}
{'virginica' }
CodingMat = Mdl.CodingMatrix
CodingMat = 3×3
1 1 0
-1 0 1
0 -1 -1
Un diseño de codificación uno contra uno para tres clases produce tres alumnos binarios. Las columnas corresponden a los alumnos y las filas corresponden a las clases.CodingMat
El orden de clasees es el mismo que el orden en .Mdl.ClassNames
Por ejemplo, es e indica que el software entrena al primer aprendiz binario SVM utilizando todas las observaciones clasificadas como y .CodingMat(:,1)
[1; –1; 0]
'setosa'
'versicolor'
Porque corresponde a , es la clase positiva; corresponde a , por lo que es la clase negativa.'setosa'
1
'versicolor'
–1
Puede acceder a cada alumno binario mediante la indexación de celdas y la notación de puntos.
Mdl.BinaryLearners{1} % The first binary learner
ans = classreg.learning.classif.CompactClassificationSVM ResponseName: 'Y' CategoricalPredictors: [] ClassNames: [-1 1] ScoreTransform: 'none' Beta: [4x1 double] Bias: 1.4505 KernelParameters: [1x1 struct] Properties, Methods
Calcular el error de clasificación de la resustitución.
error = resubLoss(Mdl)
error = 0.0067
El error de clasificación en los datos de entrenamiento es pequeño, pero el clasificador podría ser un modelo sobreajustado. Puede validar el clasificador mediante y calcular el error de clasificación de validación cruzada en su lugar.crossval
Entrenar un modelo ECOC compuesto por múltiples modelos binarios de clasificación lineal.
Cargue el conjunto de datos de PNL.
load nlpdata
es una matriz dispersa de datos predictores, y es un vector categórico de etiquetas de clase.X
Y
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.fitcecoc
CompactClassificationECOC
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.X
Y
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.Mdl
ClassificationECOC
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.CVMdl
ClassificationPartitionedECOC
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.
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.predict
resubPredict
'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.Mdl
ClassificationECOC
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 .Posterior
Mdl.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
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.279
452
De las 16 etiquetas distintas, sólo 13 se representan en la respuesta ( ).Y
Cada etiqueta describe varios grados de arritmia, y el 54,20% de las observaciones están en clase.1
Entrenar clasificador ECOC uno contra todos
Cree una plantilla de conjunto. Debe especificar al menos tres argumentos: un método, un número de alumnos y el tipo de alumno. En este ejemplo, especifique para el método, para el número de alumnos y una plantilla de árbol de decisión que usa divisiones suplentes porque faltan observaciones.'GentleBoost'
100
tTree = templateTree('surrogate','on'); tEnsemble = templateEnsemble('GentleBoost',100,tTree);
es un objeto de plantilla.tEnsemble
La mayoría de sus propiedades están vacías, pero el software las llena con sus valores predeterminados durante el entrenamiento.
Entrene a un clasificador ECOC uno contra todo utilizando los conjuntos de árboles de decisión como estudiantes binarios. Para acelerar el entrenamiento, utilice binning y computación paralela.
Binning ( ) — Cuando tiene un conjunto de datos de entrenamiento grande, puede acelerar el entrenamiento (una posible disminución de la precisión) mediante el argumento de par nombre-valor.'NumBins',50
'NumBins'
Este argumento solo es válido cuando se utiliza un alumno de árbol.fitcecoc
Si especifica el valor, el software coloca cada predictor numérico en un número especificado de bins de equiprobables y, a continuación, crece árboles en los índices bin en lugar de los datos originales.'NumBins'
Puede probar primero y, a continuación, cambiar el valor en función de la precisión y la velocidad de entrenamiento.'NumBins',50
'NumBins'
Computación paralela ( ) — Con una licencia de Parallel Computing Toolbox, puede acelerar el cálculo mediante la informática paralela, que envía a cada alumno binario a un trabajador del grupo.'Options',statset('UseParallel',true)
El número de trabajadores depende de la configuración del sistema. Cuando se utilizan árboles de decisión para alumnos binarios, se paraleliza el entrenamiento mediante Intel® Threading Building Blocks (TBB) para sistemas de doble núcleo y superiores.fitcecoc
Por lo tanto, especificar la opción no es útil en un solo equipo.'UseParallel'
Utilice esta opción en un clúster.
Además, especifique que las probabilidades anteriores son 1/ , donde el número de clases distintas es 13.KK
options = statset('UseParallel',true); Mdl = fitcecoc(X,Y,'Coding','onevsall','Learners',tEnsemble,... 'Prior','uniform','NumBins',50,'Options',options);
Starting parallel pool (parpool) using the 'local' profile ... Connected to the parallel pool (number of workers: 6).
es un modelo.Mdl
ClassificationECOC
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.CVMdl
ClassificationPartitionedECOC
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.BinEdges
discretize
X = Mdl.X; % Predictor data Xbinned = zeros(size(X)); edges = Mdl.BinEdges; % Find indices of binned predictors. idxNumeric = find(~cellfun(@isempty,edges)); if iscolumn(idxNumeric) idxNumeric = idxNumeric'; end for j = idxNumeric x = X(:,j); % Convert x to array if x is a table. if istable(x) x = table2array(x); end % Group x into bins by using the discretize function. xbinned = discretize(x,[-inf; edges{j}; inf]); Xbinned(:,j) = xbinned; end
contiene los índices bin, que van desde 1 hasta el número de ubicaciones, para los predictores numéricos. valores son para los predictores categóricos.Xbinned
Xbinned
0
Si contiene s, entonces los valores correspondientes son s.X
NaN
Xbinned
NaN
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
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'
datastore
NaN
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 .rng
tallrng
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.mdlLinear
CompactClassificationECOC
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.templateKernel
fitcecoc
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.mdlKernel
CompactClassificationECOC
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 .mdlKernel
mdlLinear
Tbl
— Datos de muestraDatos de ejemplo, especificados como una tabla. Cada fila de corresponde a una observación, y cada columna corresponde a un predictor.Tbl
Opcionalmente, puede contener una columna adicional para la variable de respuesta.Tbl
No se aceptan variables de varias columnas y matrices de celdas distintas de las matrices de celdas de vectores de caracteres.
Si contiene la variable de respuesta y desea utilizar todas las variables restantes como predictores, especifique la variable de respuesta mediante .Tbl
Tbl
ResponseVarName
Si contiene la variable de respuesta y desea utilizar solo un subconjunto de las variables restantes como predictores, especifique una fórmula mediante .Tbl
Tbl
Fórmula
Si no contiene la variable de respuesta, especifique una variable de respuesta mediante .Tbl
Y
La longitud de la variable de respuesta y el número de filas deben ser iguales.Tbl
Nota
Para el entrenamiento de modelos de clasificación lineal o de kernel, no admite tablas.fitcecoc
Es decir, si es o , contiene una plantilla de alumno de modelo de clasificación lineal (consulte ), o contiene una plantilla de alumno de clasificación del núcleo (consulte ), no puede proporcionar , , o .Learners
'linear'
'kernel'
templateLinear
templateKernel
Tbl
ResponseVarName
Fórmula
Proporcione una matriz de datos predictores ( ) y una matriz de respuestas ( ) en su lugar.X
Y
Tipos de datos: table
ResponseVarName
— Nombre de la variable de respuestaTbl
Nombre de la variable de respuesta, especificado como el nombre de una variable en .Tbl
Debe especificar como vector de caracteres o escalar de cadena.ResponseVarName
Por ejemplo, si la variable de respuesta se almacena como , especifice como .Y
Tbl.Y
'Y'
De lo contrario, el software trata todas las columnas de , incluidos , como predictores al entrenar el modelo.Tbl
Y
La variable de respuesta debe ser una matriz categórica, de carácter o de cadena, un vector lógico o numérico o una matriz de celdas de vectores de caracteres. Si es una matriz de caracteres, cada elemento de la variable de respuesta debe corresponder a una fila de la matriz.Y
Se recomienda especificar el orden de las clases mediante el argumento de par nombre-valor.ClassNames
Tipos de datos: char
| string
formula
— Modelo explicativo de variable de respuesta y subconjunto de variables predictorasModelo explicativo de la variable de respuesta y un subconjunto de las variables predictoras, especificadas como vector de caracteres o escalar de cadena en el formulario.'Y~X1+X2+X3'
En este formulario, representa la variable de respuesta y , , y representa las variables predictoras.Y
X1
X2
X3
Para especificar un subconjunto de variables como predictores para entrenar el modelo, utilice una fórmula.Tbl
Si especifica una fórmula, el software no utiliza ninguna variable que no aparezca en .Tbl
Fórmula
Los nombres de variable de la fórmula deben ser ambos nombres de variable en ( ) como identificadores válidos.Tbl
Tbl.Properties.VariableNames
MATLAB®
Puede verificar los nombres de las variables mediante la función.Tbl
isvarname
El código siguiente devuelve logical ( ) para cada variable que tiene un nombre de variable válido.1
true
Si los nombres de variable en no son válidos, a continuación, convertirlos mediante la función.
cellfun(@isvarname,Tbl.Properties.VariableNames)
Tbl
matlab.lang.makeValidName
Tbl.Properties.VariableNames = matlab.lang.makeValidName(Tbl.Properties.VariableNames);
Tipos de datos: char
| string
Y
— Etiquetas de claseEtiquetas de clase a las que se entrena el modelo ECOC, especificadas como una matriz categórica, de carácter o de cadena, un vector lógico o numérico o una matriz de celdas de vectores de caracteres.
Si es una matriz de caracteres, cada elemento debe corresponder a una fila de la matriz.Y
La longitud y el número de filas de o debe ser igual.Y
Tbl
X
Se recomienda especificar el orden de clases mediante el argumento de par nombre-valor.ClassNames
Tipos de datos: categorical
| char
| string
| logical
| single
| double
| cell
X
— Datos del predictorDatos del predictor, especificados como una matriz completa o dispersa.
La longitud y el número de observaciones deben ser iguales.Y
X
Para especificar los nombres de los predictores en el orden de su aparición en , utilice el argumento de par nombre-valor.X
PredictorNames
Nota
Para los alumnos de clasificación lineal, si orienta para que las observaciones se correspondan con columnas y especifique , puede experimentar una reducción significativa en el tiempo de optimización-ejecución.X
'ObservationsIn','columns'
Para todos los demás alumnos, oriente para que las observaciones correspondan a filas.X
fitcecoc
admite matrices dispersas solo para entrenar modelos de clasificación lineal.
Tipos de datos: double
| single
Nota
El software trata , vector de caracteres vacíos ( ), cadena vacía ( ), y elementos como datos que faltan.NaN
''
""
<missing>
<undefined>
El software elimina las filas correspondientes a los valores que faltan en .X
Y
Sin embargo, el tratamiento de los valores que faltan en varía entre los estudiantes binarios.X
Para obtener más información, consulte las funciones de entrenamiento de los alumnos binarios: , , , , , , , , , o .fitcdiscr
fitckernel
fitcknn
fitclinear
fitcnb
fitcsvm
fitctree
fitcensemble
La eliminación de observaciones disminuye el entrenamiento efectivo o el tamaño de la muestra de validación cruzada.
Especifique pares opcionales separados por comas de argumentos. es el nombre del argumento y es el valor correspondiente. deben aparecer entre comillas.Name,Value
Name
Value
Name
Puede especificar varios argumentos de par de nombre y valor en cualquier orden como .Name1,Value1,...,NameN,ValueN
'Learners','tree','Coding','onevsone','CrossVal','on'
Nota
No puede utilizar ningún argumento de par nombre-valor de validación cruzada junto con el argumento de par nombre-valor.'OptimizeHyperparameters'
Puede modificar la validación cruzada solo mediante el argumento de par nombre-valor.'OptimizeHyperparameters'
'HyperparameterOptimizationOptions'
'Coding'
— Diseño de codificación'onevsone'
(predeterminado) | 'allpairs'
| 'binarycomplete'
| 'denserandom'
| 'onevsall'
| 'ordinal'
| 'sparserandom'
| 'ternarycomplete'
| matriz numéricaNombre de diseño de codificación, especificado como el par separado por comas que consta de una matriz numérica o un valor en esta tabla.'Coding'
Valor | Número de estudiantes binarios | Descripción |
---|---|---|
Y'allpairs' 'onevsone' | ( – 1)/2KK | Para cada alumno binario, una clase es positiva, otra es negativa y el software ignora el resto. Este diseño agota todas las combinaciones de asignaciones de pares de clases. |
'binarycomplete' | Este diseño divide las clases en todas las combinaciones binarias y no omite ninguna clase. Para cada alumno binario, todas las asignaciones de clase son y con al menos una clase positiva y negativa en la asignación.-1 1 | |
'denserandom' | Aleatorio, pero aproximadamente 10 registros2K | Para cada alumno binario, el software asigna clases aleatoriamente en clases positivas o negativas, con al menos uno de cada tipo. Para obtener más información, consulte .Matrices de diseño de codificación aleatoria |
'onevsall' | K | Para cada alumno binario, una clase es positiva y el resto son negativos. Este diseño agota todas las combinaciones de asignaciones de clases positivas. |
'ordinal' | – 1K | Para el primer alumno binario, la primera clase es negativa y el resto positivo. Para el segundo alumno binario, las dos primeras clases son negativas, el resto positivo, etc. |
'sparserandom' | Aleatorio, pero aproximadamente 15 registros2K | Para cada alumno binario, el software asigna aleatoriamente clases como positivas o negativas con probabilidad 0,25 para cada uno, e ignora las clases con probabilidad 0,5. Para obtener más información, consulte .Matrices de diseño de codificación aleatoria |
'ternarycomplete' | Este diseño divide las clases en todas las combinaciones ternarias. Todas las asignaciones de clases son , , y con al menos una clase positiva y una clase negativa en la asignación.0 -1 1 |
También puede especificar un diseño de codificación mediante una matriz de codificación personalizada. La matriz de codificación personalizada es una matriz -by-.KL Cada fila corresponde a una clase y cada columna corresponde a un alumno binario. El orden de clases (filas) corresponde al orden en .ClassNames
Componga la matriz siguiendo estas pautas:
Cada elemento de la matriz de codificación personalizada debe ser , , o , y el valor debe corresponder a una asignación de clase dicotómica.-1
0
1
Esta tabla describe el significado de , es decir, la clase que el alumno asigna a las observaciones en la clase .Coding(i,j)
j
i
Valor | Asignación de clase sin dicotómica |
---|---|
–1 | El alumno asigna observaciones en clase a una clase negativa.j i |
0 | Antes del entrenamiento, el alumno elimina las observaciones en clase del conjunto de datos.j i |
1 | El alumno asigna observaciones en clase a una clase positiva.j i |
Cada columna debe contener al menos una o .-1
1
Para todos los índices de columna, de tal manera que , , no puede ser igual y no puede ser igual a .i
j
i
j
Coding(:,i)
Coding(:,j)
Coding(:,i)
-Coding(:,j)
Todas las filas de la matriz de codificación personalizada deben ser diferentes.
Para obtener más información sobre la forma de matrices de diseño de codificación personalizadas, consulte .Matrices de diseño de codificación personalizadas
Ejemplo: 'Coding','ternarycomplete'
Tipos de datos: char
| string
| double
| single
| int16
| int32
| int64
| int8
'FitPosterior'
— Indicador que indica si se deben transformar las puntuaciones en probabilidades posterioresfalse
0
(predeterminado) | Otrue
1
Marcador que indica si se deben transformar las puntuaciones en probabilidades posteriores, especificados como el par separado por comas que consta de y un ( ) o ( ).'FitPosterior'
true
1
false
0
Si es , entonces el software transforma las puntuaciones de clasificación de aprendizaje binario a probabilidades posteriores.FitPosterior
true
Puede obtener probabilidades posteriores utilizando kfoldPredict
, predict
O resubPredict
.
no admite probabilidades posteriores apropiadas si:fitcecoc
El método de conjunto es , , , , o .AdaBoostM2
LPBoost
RUSBoost
RobustBoost
TotalBoost
Los alumnos binarios ( ) son modelos de clasificación lineal es decir, lineales o de kernel que implementan SVM.Learners
Para obtener probabilidades posteriores para los modelos de clasificación lineal o del núcleo, implemente la regresión logística en su lugar.
Ejemplo: 'FitPosterior',true
Tipos de datos: logical
'Learners'
— Plantillas de aprendizaje binario'svm'
(predeterminado) | 'discriminant'
| 'kernel'
| 'knn'
| 'linear'
| 'naivebayes'
| 'tree'
| objeto de plantilla | vector de celda de objetos de plantillaPlantillas de aprendizaje binario, especificadas como el par separado por comas que consta de un vector de caracteres, un escalar de cadena, un objeto de plantilla o un vector de celda de objetos de plantilla.'Learners'
En concreto, puede especificar clasificadores binarios como SVM y los conjuntos que utilizan , , y , para resolver problemas multiclase.GentleBoost
LogitBoost
RobustBoost
Sin embargo, también admite modelos multiclase como clasificadores binarios.fitcecoc
Si es un vector de caracteres o un escalar de cadena, el software entrena a cada alumno binario utilizando los valores predeterminados del algoritmo especificado.Learners
Esta tabla resume los algoritmos disponibles.
Valor | Descripción |
---|---|
'discriminant' | Análisis discriminatorio. Para ver las opciones predeterminadas, consulte .templateDiscriminant |
'kernel' | Modelo de clasificación del núcleo. Para ver las opciones predeterminadas, consulte .templateKernel |
'knn' | -vecinos más cercanos.k Para ver las opciones predeterminadas, consulte .templateKNN |
'linear' | Modelo de clasificación lineal. Para ver las opciones predeterminadas, consulte .templateLinear |
'naivebayes' | Bayes ingenuos. Para ver las opciones predeterminadas, consulte .templateNaiveBayes |
'svm' | Svm. Para ver las opciones predeterminadas, consulte .templateSVM |
'tree' | Arboles de clasificación. Para ver las opciones predeterminadas, consulte .templateTree |
Si es un objeto de plantilla, cada alumno binario entrena de acuerdo con las opciones almacenadas.Learners
Puede crear un objeto de plantilla utilizando:
, para análisis discriminatorios.templateDiscriminant
, para el aprendizaje en conjunto.templateEnsemble
Al menos debe especificar el método de aprendizaje ( ), el número de alumnos ( ) y el tipo de alumno ( ).Method
NLearn
Learners
No se puede utilizar el método ensemble para el aprendizaje binario.AdaBoostM2
, para la clasificación del núcleo.templateKernel
, para -vecinos más cercanos.templateKNN
k
, para clasificación lineal.templateLinear
, para los bayes ingenuos.templateNaiveBayes
, para SVM.templateSVM
, para árboles de clasificación.templateTree
Si es un vector de celda de objetos de plantilla, entonces:Learners
Cell corresponde al alumno binario (en otras palabras, columna de la matriz de diseño de codificación) y el vector de celda debe tener longitud . es el número de columnas en la matriz de diseño de codificación.jjjLL Para obtener más información, consulte .Coding
Para utilizar una de las funciones de pérdida integradas para la predicción, todos los alumnos binarios deben devolver una puntuación en el mismo rango. Por ejemplo, no puede incluir aprendizajes binarios SVM predeterminados con los alumnos binarios de Bayes ingenuos predeterminados. El primero devuelve una puntuación en el intervalo (-,o), y el segundo devuelve una probabilidad posterior como una puntuación. De lo contrario, debe proporcionar una pérdida personalizada como identificador de función para funciones como predict
Y loss
.
No puede especificar plantillas de alumno sin modelo de clasificación lineal con ninguna otra plantilla.
Del mismo modo, no puede especificar plantillas de alumnos del modelo de clasificación del kernel con ninguna otra plantilla.
De forma predeterminada, el software entrena a los alumnos mediante plantillas SVM predeterminadas.
Ejemplo: 'Learners','tree'
'NumBins'
— Número de ubicaciones para predictores numéricos[]
(predeterminado) | scalar entero positivoNúmero de ubicaciones para predictores numéricos, especificado como el par separado por comas que consta de un escalar entero positivo.'NumBins'
Este argumento sólo es válido cuando
fitcecoc
utiliza un alumno de árbol, es decir, es o un objeto de plantilla creado mediante , o un objeto de plantilla creado mediante el uso de alumnos débiles de árbol.'Learner'
'tree'
templateTree
templateEnsemble
Si el valor está vacío (predeterminado), el software no bin ningún predictor.'NumBins'
Si especifica el valor como un escalar entero positivo, el software coloca cada predictor numérico en un número especificado de bins equiprobables y, a continuación, crece árboles en los índices de ubicación en lugar de los datos originales.'NumBins'
Si el valor supera el número ( ) de valores únicos para un predictor,'NumBins'
u
fitcecoc
bins el predictor en contenedores.u
fitcecoc
no bin predictores categóricos.
Cuando se utiliza un conjunto de datos de entrenamiento grande, esta opción de binning acelera el entrenamiento, pero provoca una posible disminución de la precisión. Puede probar primero y, a continuación, cambiar el valor en función de la precisión y la velocidad de entrenamiento.'NumBins',50
'NumBins'
Un modelo entrenado almacena los bordes de la ubicación en la propiedad.BinEdges
Ejemplo: 'NumBins',50
Tipos de datos: single
| double
'NumConcurrent'
— Número de estudiantes binarios entrenados simultáneamente1
(predeterminado) | scalar entero positivoNúmero de alumnos binarios entrenados simultáneamente, especificado como el par separado por comas que consta de un escalar entero positivo.'NumConcurrent'
El valor predeterminado es , lo que significa que entrena a los alumnos binarios secuencialmente.1
fitcecoc
Nota
Esta opción solo se aplica cuando se utiliza en matrices altas.fitcecoc
Consulte para obtener más información.Matrices altas
Tipos de datos: single
| double
'ObservationsIn'
— Dimensión de observación de datos predictor'rows'
(predeterminado) | 'columns'
Dimensión de observación de datos predictor, especificada como el par separado por comas que consta de y o .'ObservationsIn'
'columns'
'rows'
Nota
Para los alumnos de clasificación lineal, si orienta para que las observaciones se correspondan con columnas y especifique , puede experimentar una reducción significativa en el tiempo de optimización-ejecución.X
'ObservationsIn','columns'
Para todos los demás alumnos, oriente para que las observaciones correspondan a filas.X
Ejemplo: 'ObservationsIn','columns'
'Verbose'
— Nivel de verbosidad0
(predeterminado) | 1
| 2
Nivel de detalle, especificado como el par separado por comas que consta de y , , o . controla la cantidad de información de diagnóstico por alumno binario que el software muestra en la ventana de comandos.'Verbose'
0
1
2
Verbose
En esta tabla se resumen las opciones de nivel de detalle disponibles.
Valor | Descripción |
---|---|
0 | El software no muestra información de diagnóstico. |
1 | El software muestra mensajes de diagnóstico cada vez que entrena a un nuevo alumno binario. |
2 | El software muestra mensajes de diagnóstico adicionales cada vez que entrena a un nuevo alumno binario. |
Cada alumno binario tiene su propio nivel de detalle que es independiente de este argumento de par nombre-valor. Para cambiar el nivel de detalle de un alumno binario, cree un objeto de plantilla y especifique el argumento de par nombre-valor.'Verbose'
A continuación, pase el objeto de plantilla mediante el argumento de par nombre-valor.fitcecoc
'Learners'
Ejemplo: 'Verbose',1
Tipos de datos: double
| single
'CrossVal'
— Bandera para entrenar clasificador oriundo'off'
(predeterminado) | 'on'
Marcar para entrenar un clasificador validado cruzado, especificado como el par separado por comas que consta de y o .'Crossval'
'on'
'off'
Si especifica , el software entrena un clasificador validado cruzadamente con 10 pliegues.'on'
Puede invalidar esta configuración de validación cruzada mediante uno de los argumentos de par , , o nombre-valor.CVPartition
Holdout
KFold
Leaveout
Solo puede usar un argumento de par nombre-valor de validación cruzada a la vez para crear un modelo validado entre sí.
Alternativamente, valide más adelante pasando aMdl
crossval
.
Ejemplo: 'Crossval','on'
'CVPartition'
— Partición de validación cruzada[]
(predeterminado) | objeto de particióncvpartition
Partición de validación cruzada, especificada como el par separado por comas que consta de y un objeto de partición creado por .'CVPartition'
cvpartition
cvpartition
El objeto de partición especifica el tipo de validación cruzada y la indexación de los conjuntos de entrenamiento y validación.
Para crear un modelo validado entre referencias cruzadas, puede utilizar uno de estos cuatro argumentos de par nombre-valor solo: , , , o .CVPartition
Holdout
KFold
Leaveout
Ejemplo: Supongamos que crea una partición aleatoria para la validación cruzada de 5 veces en 500 observaciones mediante .cvp = cvpartition(500,'KFold',5)
A continuación, puede especificar el modelo validado entre cruces mediante .'CVPartition',cvp
'Holdout'
— Fracción de datos para la validación de retenciónFracción de los datos utilizados para la validación de retención, especificada como el par separado por comas que consta de y un valor escalar en el intervalo (0,1).'Holdout'
Si usted especifica, después el software completa estos pasos:'Holdout',p
Seleccione y reserve aleatoriamente % de los datos como datos de validación y entrene el modelo con el resto de los datos.p*100
Almacene el modelo compacto y entrenado en la propiedad del modelo validado de forma cruzada.Trained
Para crear un modelo validado entre referencias cruzadas, puede utilizar uno de estos cuatro argumentos de par nombre-valor solo: , , , o .CVPartition
Holdout
KFold
Leaveout
Ejemplo: 'Holdout',0.1
Tipos de datos: double
| single
'KFold'
— Número de pliegues10
(predeterminado) | valor entero positivo mayor que 1Número de pliegues que se van a utilizar en un modelo validado por cruz, especificado como el par separado por comas que consta de y un valor entero positivo mayor que 1.'KFold'
Si usted especifica, después el software completa estos pasos:'KFold',k
Particione aleatoriamente los datos en conjuntos.k
Para cada conjunto, reserve el conjunto como datos de validación y entrene el modelo con el otro k
– 1 Establece.
Almacene los modelos compactos y entrenados en las celdas de un vector de celda -by-1 en la propiedad del modelo validado cruzadamente.k
k
Trained
Para crear un modelo validado entre referencias cruzadas, puede utilizar uno de estos cuatro argumentos de par nombre-valor solo: , , , o .CVPartition
Holdout
KFold
Leaveout
Ejemplo: 'KFold',5
Tipos de datos: single
| double
'Leaveout'
— Dejar un indicador de validación cruzada'off'
(predeterminado) | 'on'
Deje el indicador de validación cruzada uno-out, especificado como el par separado por comas que consta de y o .'Leaveout'
'on'
'off'
Si especifica , entonces, para cada una de las observaciones, dónde está , el software:'Leaveout','on'
nnsize(Mdl.X,1)
Reserva la observación como datos de validación y entrena el modelo utilizando las otras observaciones – 1n
Almacena los modelos compactos y entrenados en las celdas de un vector de celda -by-1 en la propiedad del modelo validado cruzadamente.nnTrained
Para crear un modelo validado entre referencias cruzadas, puede utilizar una de estas cuatro opciones solo: , , , o .CVPartition
Holdout
KFold
Leaveout
Nota
No se recomienda dejar un solo para validar modelos ECOC de validación cruzada compuestos por alumnos de modelos de clasificación lineal o de kernel.
Ejemplo: 'Leaveout','on'
'CategoricalPredictors'
— Lista de predictores categóricos'all'
Lista de predictores categóricos, especificada como el par separado por comas que consta de y uno de los valores de esta tabla.'CategoricalPredictors'
Valor | Descripción |
---|---|
Vector de enteros positivos | Cada entrada del vector es un valor de índice correspondiente a la columna de los datos predictores ( o ) que contiene una variable categórica.X Tbl |
Vector lógico | Una entrada significa que la columna correspondiente de datos predictores ( o ) es una variable categórica.true X Tbl |
Matriz de caracteres | Cada fila de la matriz es el nombre de una variable predictora. Los nombres deben coincidir con las entradas de .PredictorNames Rellena los nombres con espacios en blanco adicionales para que cada fila de la matriz de caracteres tenga la misma longitud. |
Matriz de cadenas o matriz de celdas de vectores de caracteres | Cada elemento de la matriz es el nombre de una variable predictora. Los nombres deben coincidir con las entradas de .PredictorNames |
'todos' | Todos los predictores son categóricos. |
La especificación de es apropiada si:'CategoricalPredictors'
Al menos un predictor es categórico y todos los estudiantes binarios son árboles de clasificación, estudiantes ingenuos de Bayes, SVM o conjuntos de árboles de clasificación.
Todos los predictores son categóricos y al menos un alumno binario es NN.k
Si especifica para cualquier otro alumno, el software advierte que no puede entrenar a ese alumno binario.'CategoricalPredictors'
Por ejemplo, el software no puede entrenar a los alumnos del modelo de clasificación lineal o del núcleo mediante predictores categóricos.
Cada alumno identifica y trata los predictores categóricos de la misma manera que la función de ajuste correspondiente al alumno. Vea los alumnos más cercanos, los estudiantes ingenuos de Bayes, los alumnos de SVM y los que aprenden árboles.'CategoricalPredictors'
fitcknn
k'CategoricalPredictors'
fitcnb
'CategoricalPredictors'
fitcsvm
'CategoricalPredictors'
fitctree
Ejemplo: 'CategoricalPredictors','all'
Tipos de datos: single
| double
| logical
| char
| string
| cell
'ClassNames'
— Nombres de las clases a utilizar para la formaciónNombres de clases que se usan para el entrenamiento, especificados como el par separado por comas que consta de y una matriz categórica, de carácter o de cadena, un vector lógico o numérico, o una matriz de celdas de vectores de caracteres. debe tener el mismo tipo de datos que .'ClassNames'
ClassNames
Y
Si es una matriz de caracteres, cada elemento debe corresponder a uno de la matriz.ClassNames
Fila
Utilícelo para:ClassNames
Ordene las clases durante el entrenamiento.
Especifique el orden de cualquier dimensión de argumento de entrada o salida que corresponda al orden de clases. Por ejemplo, se utiliza para especificar el orden de las dimensiones o el orden de columna de las puntuaciones de clasificación devueltas por .ClassNames
Cost
predict
Seleccione un subconjunto de clases para el entrenamiento. Por ejemplo, supongamos que el conjunto de todos los nombres de clase distintos en es .Y
{'a','b','c'}
Para entrenar el modelo mediante observaciones de clases y solo, especifique .'a'
'c'
'ClassNames',{'a','c'}
El valor predeterminado para es el conjunto de todos los nombres de clase distintos en .ClassNames
Y
Ejemplo: 'ClassNames',{'b','g'}
Tipos de datos: categorical
| char
| string
| logical
| single
| double
| cell
'Cost'
— Coste de clasificación erróneaCoste de clasificación errónea, especificado como el par separado por comas que consta de una matriz o estructura cuadrada.'Cost'
Si especifica:
La matriz cuadrada , entonces es el costo de clasificar un punto en clase si su clase verdadera es .Cost
Cost(i,j)
j
i
Es decir, las filas corresponden a la clase true y las columnas corresponden a la clase predicha. Para especificar el orden de clases para las filas y columnas correspondientes de , especifique además el argumento de par nombre-valor.Cost
ClassNames
La estructura , a continuación, debe tener dos campos:S
, que contiene los nombres de clase como una variable del mismo tipo de datos queS.ClassNames
Y
, que contiene la matriz de costes con filas y columnas ordenadas como enS.ClassificationCosts
S.ClassNames
El valor predeterminado es ones(
Dónde
K
) -
eye(K
)K
es el número de clases distintas.
Ejemplo: 'Cost',[0 1 2 ; 1 0 2; 2 2 0]
Tipos de datos: double
| single
| struct
'Options'
— Opciones de computación paralela[]
(predeterminado) | estructura devuelta porstatset
Opciones de computación paralela, especificadas como el par separado por comas que consta de y una matriz de estructura devuelta por .'Options'
statset
Estas opciones requieren .Parallel Computing Toolbox™ fitcecoc
utiliza , , y campos.'Streams'
'UseParallel'
'UseSubtreams'
Esta tabla resume las opciones disponibles.
Opción | Descripción |
---|---|
'Streams' |
Un objeto o matriz de celdas de dichos objetos.
En ese caso, utilice una matriz de celdas del mismo tamaño que el grupo paralelo. Si un grupo paralelo no está abierto, el software intenta abrir uno (dependiendo de sus preferencias) y debe proporcionar una sola secuencia de números aleatorios. |
'UseParallel' | Si tiene , puede invocar un grupo de trabajadores estableciendo .Parallel Computing Toolbox Cuando se utilizan árboles de decisión para estudiantes binarios,
|
'UseSubstreams' | Establézalo para calcular en paralelo mediante la secuencia especificada por .true 'Streams' El valor predeterminado es .false Por ejemplo, establezca en un tipo que permita subsecuencias, como o .Streams 'mlfg6331_64' 'mrg32k3a' |
Una práctica recomendada para garantizar resultados más predecibles es usar y crear explícitamente un grupo paralelo antes de invocar la informática paralela medianteparpool
(Parallel Computing Toolbox) fitcecoc
.
Ejemplo: 'Options',statset('UseParallel',true)
Tipos de datos: struct
'PredictorNames'
— Nombres de variables predictorasNombres de variables predictoras, especificados como el par separado por comas que consta de y una matriz de cadenas de nombres únicos o matriz de celdas de vectores de caracteres únicos.'PredictorNames'
La funcionalidad de depende de la forma en que proporcione los datos de entrenamiento.'PredictorNames'
Si proporciona y , entonces puede utilizar para dar las variables predictoras en los nombres.X
Y
'PredictorNames'
X
El orden de los nombres en debe corresponder al orden de columna de .PredictorNames
X
Es decir, es el nombre de , es el nombre de , y así sucesivamente.PredictorNames{1}
X(:,1)
PredictorNames{2}
X(:,2)
Además, y debe ser igual.size(X,2)
numel(PredictorNames)
De forma predeterminada, es .PredictorNames
{'x1','x2',...}
Si proporciona , entonces puede utilizar para elegir qué variables predictoras utilizar en el entrenamiento.Tbl
'PredictorNames'
Es decir fitcecoc
utiliza sólo las variables predictoras en y la variable de respuesta en el entrenamiento.PredictorNames
debe ser un subconjunto de y no puede incluir el nombre de la variable de respuesta.PredictorNames
Tbl.Properties.VariableNames
De forma predeterminada, contiene los nombres de todas las variables predictoras.PredictorNames
Es una buena práctica especificar los predictores para el entrenamiento usando uno o solo.'PredictorNames'
Fórmula
Ejemplo: 'PredictorNames',{'SepalLength','SepalWidth','PetalLength','PetalWidth'}
Tipos de datos: string
| cell
'Prior'
— Probabilidades anteriores'empirical'
(predeterminado) | 'uniform'
| vector numérico | matriz de estructuraProbabilidades anteriores para cada clase, especificadas como el par separado por comas que consta de y un valor en esta tabla.'Prior'
Valor | Descripción |
---|---|
'empirical' | Las probabilidades anteriores de la clase son las frecuencias relativas de la clase en .Y |
'uniform' | Todas las probabilidades anteriores de clase son iguales a 1/ , donde está el número de clases.KK |
vector numérico | Cada elemento es una probabilidad previa de clase. Ordene los elementos según o especifique el orden utilizando el argumento de par nombre-valor.Mdl .ClassNames ClassNames El software normaliza los elementos de tal forma que sume a .1 |
Estructura |
Una estructura con dos campos:
|
Para obtener más detalles sobre cómo el software incorpora probabilidades anteriores de clase, véase .Probabilidades y costos anteriores
Ejemplo: struct('ClassNames',{{'setosa','versicolor','virginica'}},'ClassProbs',1:3)
Tipos de datos: single
| double
| char
| string
| struct
'ResponseName'
— Nombre de la variable de respuesta'Y'
(predeterminado) | vector de caracteres | cuerda escalarNombre de la variable de respuesta, especificado como el par separado por comas que consta de un vector de caracteres o un escalar de cadena.'ResponseName'
Si proporciona , puede usar para especificar un nombre para la variable de respuesta.Y
'ResponseName'
Si suministra o , entonces no puede utilizar .ResponseVarName
Fórmula
'ResponseName'
Ejemplo: 'ResponseName','response'
Tipos de datos: char
| string
'ScoreTransform'
— Transformación de puntuación'none'
(predeterminado) | 'doublelogit'
| 'invlogit'
| 'ismax'
| 'logit'
| manija de la función | ...Transformación de puntuación, especificada como el par separado por comas que consta de un vector de caracteres, un escalar de cadena o un identificador de función.'ScoreTransform'
En esta tabla se resumen los vectores de caracteres disponibles y los escalares de cadena.
Valor | Descripción |
---|---|
'doublelogit' | 1/(1 +e–2x) |
'invlogit' | log( / (1 – ))xx |
'ismax' | Establece la puntuación de la clase con la puntuación más alta en , y establece las puntuaciones de todas las demás clases en1 0 |
'logit' | 1/(1 +e–x) |
O'none' 'identity' | (sin transformación)x |
'sign' | –1 para <0 0 para 0 0 para 0 1 para > 0x x x |
'symmetric' | 2 – 1x |
'symmetricismax' | Establece la puntuación de la clase con la puntuación más alta en , y establece las puntuaciones de todas las demás clases en1 –1 |
'symmetriclogit' | 2/(1 +e–x) – 1 |
Para una función o una función que defina, utilice su identificador de función para la transformación de puntuación.MATLAB El identificador de función debe aceptar una matriz (las puntuaciones originales) y devolver una matriz del mismo tamaño (las puntuaciones transformadas).
Ejemplo: 'ScoreTransform','logit'
Tipos de datos: char
| string
| function_handle
'Weights'
— Pesos de observaciónTbl
Pesos de observación, especificados como el par separado por comas que consta de un vector numérico de valores positivos o el nombre de una variable en .'Weights'
Tbl
El software sopesa las observaciones en cada fila de o con el valor correspondiente en .X
Tbl
Weights
El tamaño de debe ser igual al número de filas de o .Weights
X
Tbl
Si especifica los datos de entrada como una tabla , puede ser el nombre de una variable que contenga un vector numérico.Tbl
Weights
Tbl
En este caso, debe especificar como vector de caracteres o escalar de cadena.Weights
Por ejemplo, si el vector de ponderaciones se almacena como , especifice como .W
Tbl.W
'W'
De lo contrario, el software trata todas las columnas de , incluidos , como predictores o la respuesta al entrenar el modelo.Tbl
W
El software se normaliza para sumar hasta el valor de la probabilidad anterior en la clase respectiva.Weights
De forma predeterminada, esWeights
ones(
Dónde n
,1)n
es el número de observaciones en o .X
Tbl
Tipos de datos: double
| single
| char
| string
'OptimizeHyperparameters'
— Parámetros para optimizar'none'
(predeterminado) | 'auto'
| 'all'
| matriz de cadenas o matriz de celdas de nombres de parámetros elegibles | vector de objetosoptimizableVariable
Parámetros para optimizar, especificados como el par separado por comas que consta de y uno de los siguientes:'OptimizeHyperparameters'
— No optimizar.'none'
— Utilizar junto con los parámetros predeterminados para los :'auto'
{'Coding'}
Learners
(predeterminado) —Learners
'svm'
{'BoxConstraint','KernelScale'}
• —Learners
'discriminant'
{'Delta','Gamma'}
• —Learners
'kernel'
{'KernelScale','Lambda'}
• —Learners
'knn'
{'Distance','NumNeighbors'}
• —Learners
'linear'
{'Lambda','Learner'}
• —Learners
'naivebayes'
{'DistributionNames','Width'}
• —Learners
'tree'
{'MinLeafSize'}
— Optimizar todos los parámetros elegibles.'all'
Matriz de cadenas o matriz de celdas de nombres de parámetros elegibles
Vector de objetos, normalmente la salida deoptimizableVariable
hyperparameters
La optimización intenta minimizar la pérdida de validación cruzada (error) para variar los parámetros.fitcecoc
Para obtener información sobre la pérdida de validación cruzada en un contexto diferente, consulte .Classification Loss Para controlar el tipo de validación cruzada y otros aspectos de la optimización, utilice el par nombre-valor.HyperparameterOptimizationOptions
Nota
los valores reemplazan los valores que establezca utilizando otros argumentos de par nombre-valor.'OptimizeHyperparameters'
Por ejemplo, establecer para hacer que se apliquen los valores.'OptimizeHyperparameters'
'auto'
'auto'
Los parámetros elegibles para son:fitcecoc
— búsquedas entre y .Coding
fitcecoc
'onevsall'
'onevsone'
Los hiperparámetros elegibles para el elegido, tal como se especifica en esta tabla.Learners
Estudiantes | Hiperparámetros elegibles (Bold - Predeterminado) | Rango predeterminado |
---|---|---|
'discriminant' | Delta | Escalado de registros en el rango[1e-6,1e3] |
DiscrimType | Y'linear' 'quadratic' 'diagLinear' 'diagQuadratic' 'pseudoLinear' 'pseudoQuadratic' | |
Gamma | Valores reales en[0,1] | |
'kernel' | Lambda | Valores positivos escalado en registro en el rango[1e-3/NumObservations,1e3/NumObservations] |
KernelScale | Valores positivos escalado en registro en el rango[1e-3,1e3] | |
Learner | Y'svm' 'logistic' | |
NumExpansionDimensions | Números enteros escalados en el intervalo[100,10000] | |
'knn' | Distance | Y'cityblock' 'chebychev' 'correlation' 'cosine' 'euclidean' 'hamming' 'jaccard' 'mahalanobis' 'minkowski' 'seuclidean' 'spearman' |
DistanceWeight | Y'equal' 'inverse' 'squaredinverse' | |
Exponent | Los valores positivos en[0.5,3] | |
NumNeighbors | Valores enteros positivos escalado en registro en el rango[1, max(2,round(NumObservations/2))] | |
Standardize | Y'true' 'false' | |
'linear' | Lambda | Valores positivos escalado en registro en el rango[1e-5/NumObservations,1e5/NumObservations] |
Learner | Y'svm' 'logistic' | |
Regularization | Y'ridge' 'lasso' | |
'naivebayes' | DistributionNames | Y'normal' 'kernel' |
Width | Valores positivos escalado en registro en el rango[MinPredictorDiff/4,max(MaxPredictorRange,MinPredictorDiff)] | |
Kernel | Y'normal' 'box' 'epanechnikov' 'triangle' | |
'svm' | BoxConstraint | Valores positivos escalado en registro en el rango[1e-3,1e3] |
KernelScale | Valores positivos escalado en registro en el rango[1e-3,1e3] | |
KernelFunction | Y'gaussian' 'linear' 'polynomial' | |
PolynomialOrder | Enteros en el rango[2,4] | |
Standardize | Y'true' 'false' | |
'tree' | MaxNumSplits | Números enteros escalados en el intervalo[1,max(2,NumObservations-1)] |
MinLeafSize | Números enteros escalados en el intervalo[1,max(2,floor(NumObservations/2))] | |
NumVariablesToSample | Enteros en el rango[1,max(2,NumPredictors)] | |
SplitCriterion | Y'gdi' 'deviance' 'twoing' |
Alternativamente, utilice con el elegido, comohyperparameters
Learners
load fisheriris % hyperparameters requires data and learner params = hyperparameters('fitcecoc',meas,species,'svm');
Para ver los hiperparámetros elegibles y predeterminados, examine .params
Establezca parámetros no predeterminados pasando un vector de objetos que tengan valores no predeterminados.optimizableVariable
Por ejemplo,
load fisheriris params = hyperparameters('fitcecoc',meas,species,'svm'); params(2).Range = [1e-4,1e6];
Pase como el valor de .params
OptimizeHyperparameters
De forma predeterminada, la visualización iterativa aparece en la línea de comandoy los trazados aparecen según el número de hiperparámetros de la optimización. Para la optimización y las gráficas, la función objetivo es log(1 + cross-validation loss) para la regresión y la tasa de clasificación errónea para la clasificación. Para controlar la visualización iterativa, establezca el campo del argumento de par nombre-valor.Verbose
'HyperparameterOptimizationOptions'
Para controlar los trazados, establezca el campo del argumento de par nombre-valor.ShowPlots
'HyperparameterOptimizationOptions'
Para obtener un ejemplo, consulte .Optimizar clasificador ECOC
Ejemplo: 'auto'
'HyperparameterOptimizationOptions'
— Opciones para la optimizaciónOpciones para la optimización, especificadas como el par separado por comas que consta de y una estructura.'HyperparameterOptimizationOptions'
Este argumento modifica el efecto del argumento de par nombre-valor.OptimizeHyperparameters
Todos los campos de la estructura son opcionales.
Nombre del campo | Valores | Predeterminado |
---|---|---|
Optimizer |
búsquedas en un orden aleatorio, utilizando muestreo uniforme sin reemplazo de la cuadrícula. | 'bayesopt' |
AcquisitionFunctionName |
Las funciones de adquisición cuyos nombres incluyen no producen resultados reproducibles porque la optimización depende del tiempo de ejecución de la función objetivo. | 'expected-improvement-per-second-plus' |
MaxObjectiveEvaluations | Número máximo de evaluaciones de funciones objetivas. | para o , y toda la cuadrícula para30 'bayesopt' 'randomsearch' 'gridsearch' |
MaxTime | Límite de tiempo, especificado como un real positivo. El límite de tiempo es en segundos, medido por y . | Inf |
NumGridDivisions | Para , el número de valores en cada dimensión.'gridsearch' El valor puede ser un vector de enteros positivos que dan el número de valores para cada dimensión o un escalar que se aplica a todas las dimensiones. Este campo se omite para las variables categóricas. | 10 |
ShowPlots | Valor lógico que indica si se deben mostrar trazados. Si , este campo traza el mejor valor de función objetivo con respecto al número de iteración.true Si hay uno o dos parámetros de optimización, y si es , también se traza un modelo de la función objetivo con los parámetros.Optimizer 'bayesopt' ShowPlots | true |
SaveIntermediateResults | Valor lógico que indica si se deben guardar los resultados cuando es .Optimizer 'bayesopt' Si , este campo sobrescribe una variable de área de trabajo denominada en cada iteración.true 'BayesoptResults' La variable es un objeto.BayesianOptimization | false |
Verbose | Visualice en la línea de comandos.
Para obtener más información, consulte el argumento de par nombre-valor. | 1 |
UseParallel | Valor lógico que indica si se debe ejecutar la optimización bayesiana en paralelo, lo que requiere .Parallel Computing Toolbox Debido a la no reproducibilidad de la sincronización paralela, la optimización bayesiana paralela no produce necesariamente resultados reproducibles. Para obtener más información, consulte .Parallel Bayesian Optimization | false |
Repartition | Valor lógico que indica si se debe volver a particionar la validación cruzada en cada iteración. Si , el optimizador utiliza una sola partición para la optimización. por lo general da los resultados más robustos porque esta configuración tiene en cuenta el ruido de partición. | false |
No utilice más de uno de los tres nombres de campo siguientes. | ||
CVPartition | Un objeto, tal como lo creó .cvpartition cvpartition | si no especifica ningún campo de validación cruzada'Kfold',5 |
Holdout | Un escalar en el rango que representa la fracción de retención.(0,1) | |
Kfold | Un entero mayor que 1. |
Ejemplo: 'HyperparameterOptimizationOptions',struct('MaxObjectiveEvaluations',60)
Tipos de datos: struct
Mdl
— Modelo ECOC entrenadoClassificationECOC
| objeto modeloCompactClassificationECOC
| objeto de modelo validado cruzadamenteClassificationPartitionedECOC
| objeto de modelo validado cruzadamenteClassificationPartitionedLinearECOC
| objeto de modelo validado cruzadamenteClassificationPartitionedKernelECOC
Clasificador ECOC entrenado, devuelto como un objeto o objeto de modelo, o un objeto de modelo , , o validado entre referencias cruzadas.ClassificationECOC
CompactClassificationECOC
ClassificationPartitionedECOC
ClassificationPartitionedLinearECOC
ClassificationPartitionedKernelECOC
Esta tabla muestra cómo los tipos de objetos de modelo devueltos por fitcecoc
depende del tipo de aprendizaje binario que especifique y si realiza la validación cruzada.
Estudiantes de Modelos de Clasificación Lineal | Estudiantes del modelo de clasificación del núcleo | Validación cruzada | Objeto de modelo devuelto |
---|---|---|---|
No | No | No | ClassificationECOC |
No | No | Sí | ClassificationPartitionedECOC |
Sí | No | No | CompactClassificationECOC |
Sí | No | Sí | ClassificationPartitionedLinearECOC |
No | Sí | No | CompactClassificationECOC |
No | Sí | Sí | ClassificationPartitionedKernelECOC |
HyperparameterOptimizationResults
— Descripción de la optimización de validación cruzada de hiperparámetrosBayesianOptimization
| tabla de hiperparámetros y valores asociadosDescripción de la optimización de validación cruzada de hiperparámetros, devuelta como un objeto o una tabla de hiperparámetros y valores asociados. no está vacío cuando el argumento de par nombre-valor no está vacío y el argumento de par nombre-valor designa a los alumnos binarios lineales o del kernel.BayesianOptimization
HyperparameterOptimizationResults
OptimizeHyperparameters
Learners
El valor depende de la configuración del argumento de par nombre-valor:HyperparameterOptimizationOptions
(predeterminado) — Objeto de clase'bayesopt'
BayesianOptimization
o — Tabla de hiperparámetros utilizados, valores de función objetivo observados (pérdida de validación cruzada) y rango de observación de menor (mejor) a mayor (peor)'gridsearch'
'randomsearch'
Tipos de datos: table
Para el entrenamiento de modelos de clasificación lineal o de kernel, no admite tablas.fitcecoc
Es decir, si es o , contiene una plantilla de alumno de modelo de clasificación lineal (consulte ), o contiene una plantilla de alumno del modelo de clasificación del núcleo ( consulte ), no puede proporcionar , , o .Learners
'linear'
'kernel'
templateLinear
templateKernel
Tbl
ResponseVarName
Fórmula
Proporcione una matriz de datos predictores ( ) y una matriz de respuestas ( ) en su lugar.X
Y
fitcecoc
admite matrices dispersas solo para entrenar modelos de clasificación lineal. Para todos los demás modelos, proporcione una matriz completa de datos predictores en su lugar.
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 el elemento ( , ) de la matriz de diseño de codificación (es decir, el código correspondiente a la clase de aprendiz binario).kjMkj
sj es la puntuación de aprendiz binario para una observación.j
es la función de pérdida binaria.g
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.]
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.]
sugieren que la decodificación ponderada por pérdidas mejora la precisión de la clasificación al mantener los valores de pérdida para todas las clases en el mismo rango dinámico.Allwein et al.
Esta tabla resume las funciones de pérdida soportadas, donde y yj es una etiqueta de clase para un alumno binario en particular (en el conjunto de números 1,1,0o), sj es la puntuación para la observación, y (jgy yj,sj).
Valor | Descripción | Dominio de puntuación | g(y yj,sj) |
---|---|---|---|
'binodeviance' | Desviación binomial | (–,o) | log[1 + exp(–2y yjsj)]/[2log(2)] |
'exponential' | Exponencial | (–,o) | exp(–y yjsj)/2 |
'hamming' | Hamming | [0,1] o (–,o) | [1 – signo(y yjsj)]/2 |
'hinge' | Bisagra | (–,o) | max(0,1 – y yjsj)/2 |
'linear' | Lineal | (–,o) | (1 – y yjsj)/2 |
'logit' | Logística | (–,o) | log[1 + exp(–y yjsj)]/[2log(2)] |
'quadratic' | Cuadrática | [0,1] | [1 – y yj(2sj – 1)]2/2 |
El software normaliza las pérdidas binarias de tal forma que la pérdida es de 0,5 cuando y yj 0, y agrega utilizando el promedio de los estudiantes binarios .[Allwein et al.]
No confunda la pérdida binaria con la pérdida de clasificación general (especificada por el argumento de par nombre-valor de las funciones y objeto), que mide el rendimiento de un clasificador ECOC en su conjunto.'LossFun'
loss
predict
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
Un reduce el problema de la clasificación con tres o más clases a un conjunto de problemas de clasificación binaria.modelo de códigos de salida de corrección de errores (ECOC)
La clasificación ECOC requiere un diseño de codificación, que determina las clases en las que se entrenan los alumnos binarios, y un esquema de decodificación, que determina cómo se agregan los resultados (predicciones) de los clasificadores binarios.
Supongamos lo siguiente:
El problema de clasificación tiene tres clases.
El diseño de codificación es uno contra uno. Para tres clases, este diseño de codificación es
El esquema de decodificación utiliza la pérdida .g
Los alumnos son SMs.
Para crear este modelo de clasificación, el algoritmo ECOC sigue estos pasos.
El alumno 1 entrena en observaciones en la clase 1 o la clase 2, y trata la clase 1 como la clase positiva y la clase 2 como la clase negativa. Los otros estudiantes son entrenados de manera similar.
Sea la matriz de diseño de codificación con elementosM MklY sl ser la puntuación de clasificación prevista para la clase positiva del alumno.l El algoritmo asigna una nueva observación a la clase () que minimiza la agregación de las pérdidas para los alumnos binarios.L
Los modelos ECOC pueden mejorar la precisión de clasificación, en comparación con otros modelos multiclase.[2]
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.binarycomplete
ternarycomplete
Sin embargo:
Si es 4, utilice el diseño de codificación en lugar de .Kternarycomplete
sparserandom
Si es 5, utilice el diseño de codificación en lugar de .Kbinarycomplete
denserandom
Puede visualizar la matriz de diseño de codificación de un clasificador ECOC entrenado introduciendo en la ventana de comandos.Mdl.CodingMatrix
Debe formar una matriz de codificación utilizando un conocimiento íntimo de la aplicación y teniendo en cuenta las restricciones computacionales. Si tiene suficiente potencia y tiempo computacional, pruebe varias matrices de codificación y elija la que tenga el mejor rendimiento (por ejemplo, compruebe las matrices de confusión para cada modelo utilizando ).confusionchart
La validación cruzada de dejar un solo out ( ) es ineficiente para conjuntos de datos con muchas observaciones.Leaveout
En su lugar, utilice -fold cross-validation ( ).kKFold
Después de entrenar un modelo, puede generar código C/C++ que predice las etiquetas para los nuevos datos. La generación de código C/C++ requiere MATLAB Coder™. Para obtener más información, consulte .Introduction to Code Generation
Las matrices de codificación personalizadas deben tener una forma determinada. El software valida matrices de codificación personalizadas garantizando:
Cada elemento es -1, 0 o 1.
Cada columna contiene al menos uno -1 y uno 1.
Para todos los vectores de columna distintos y , , y - .uvuvuv
Todos los vectores de filas son únicos.
La matriz puede separar dos clases cualquiera. Es decir, puede viajar de cualquier fila a cualquier otra fila siguiendo estas reglas:
Puede moverse verticalmente de 1 a -1 o -1 a 1.
Puede mover horizontalmente de un elemento distinto de cero a otro elemento distinto de cero.
Puede utilizar una columna de la matriz para un movimiento vertical solo una vez.
Si no es posible pasar de una fila a una fila con estas reglas, las clases y no se pueden separar por el diseño.ijij Por ejemplo, en el diseño de codificación
las clases 1 y 2 no se pueden separar de las clases 3 y 4 (es decir, no se puede mover horizontalmente del -1 en la fila 2 a la columna 2, ya que hay un 0 en esa posición). Por lo tanto, el software rechaza este diseño de codificación.
Si utiliza la informática paralela (consulte ), entrena a los alumnos binarios en paralelo.Options
fitcecoc
Probabilidades anteriores : el software normaliza las probabilidades anteriores de clase especificadas ( ) para cada alumno binario.Prior
Sea la matriz de diseño de codificación y ( , ) sea una matriz de indicadores. MIAc La matriz del indicador tiene las mismas dimensiones que .A Si el elemento correspondiente de es , entonces la matriz del indicador tiene elementos iguales a uno, y cero en caso contrario.Ac DejarM+1 YM-1 ser -por- matrices tales que:KL
M+1 • ( ,1), en el que se trata de una multiplicación de elementos (es decir, ).MIMMplus = M.*(M == 1)
Además, deje mosquenos ser vector de columna delM+1.
M-1 - - ( ,-1) (es decir, ).MIMMminus = -M.*(M == -1)
Además, deje mosquenos ser vector de columna delM-1.
Dejar Y , donde está el vector de las probabilidades anteriores de clase especificadas ( ).πPrior
Entonces, las probabilidades anteriores positivas y negativas, de clase escalar para el alumno binario sonl
donde se encuentra el número-1,1o yj es la norma de una de .a
Costo — El software normaliza la matriz de costo por ( ) para cada alumno binario.KKCCost
Para el alumno binario, el costo de clasificar una observación de clase negativa en la clase positiva esl
Del mismo modo, el costo de clasificar una observación de clase positiva en la clase negativa es
La matriz de costos para el alumno binario esl
Los modelos ECOC se adaptan a los costos de clasificación errónea al incorporarlos con probabilidades anteriores de clase. Si especifica y , el software ajusta las probabilidades anteriores de la clase de la siguiente manera:Prior
Cost
Para un número determinado de clases, el software genera matrices de diseño de codificación aleatoria de la siguiente manera.K
El software genera una de estas matrices:
Denso aleatorio — El software asigna 1 o –1 con la misma probabilidad a cada elemento de la -por-KLd matriz de diseño de codificación, donde .
Sparse random — El software asigna 1 a cada elemento de la -by-KLs matriz de diseño de codificación con probabilidad 0.25, –1 con probabilidad 0.25, y 0 con probabilidad 0.5, donde .
Si una columna no contiene al menos uno 1 y al menos uno –1, el software elimina esa columna.
Para columnas distintas y , if o , , el software se elimina de la matriz de diseño de codificación.uvuvuvv
El software genera aleatoriamente 10.000 matrices de forma predeterminada, y conserva la matriz con la distancia de fila más grande, mínima y por pares basada en la medida Hamming ( ) dada por[4]
Dónde Mkjl es un elemento de la matriz de diseño de codificación.j
De forma predeterminada y por eficiencia, vacía las propiedades , , y para todos los alumnos binarios SVM lineales. listas , en lugar de , en la visualización del modelo.fitcecoc
Alpha
SupportVectorLabels
SupportVectors
fitcecoc
Beta
Alpha
Para almacenar , , y , pasar una plantilla SVM lineal que especifica el almacenamiento de vectores de soporte a .Alpha
SupportVectorLabels
SupportVectors
fitcecoc
Por ejemplo, escriba:
t = templateSVM('SaveSupportVectors',true) Mdl = fitcecoc(X,Y,'Learners',t);
Puede eliminar los vectores de soporte y los valores relacionados pasando el modelo resultante a .ClassificationECOC
discardSupportVectors
[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.
Notas de uso y limitaciones:
Las sintaxis admitidas son:
Mdl = fitcecoc(X,Y)
Mdl = fitcecoc(X,Y,Name,Value)
: devuelve los argumentos de salida adicionales y, al especificar el argumento de par nombre-valor.[Mdl,FitInfo,HyperparameterOptimizationResults] = fitcecoc(X,Y,Name,Value)
fitcecoc
FitInfo
HyperparameterOptimizationResults
'OptimizeHyperparameters'
El argumento de salida es una matriz de estructura vacía actualmente reservada para un posible uso futuro.FitInfo
No se admiten opciones relacionadas con la validación cruzada. Los argumentos de par nombre-valor admitidos son:
'ClassNames'
'Cost'
— El valor predeterminado es .'Coding'
'onevsall'
— Para la validación cruzada, la optimización alta solo admite la validación.'HyperparameterOptimizationOptions'
'Holdout'
Por ejemplo, puede especificar .fitcecoc(X,Y,'OptimizeHyperparameters','auto','HyperparameterOptimizationOptions',struct('Holdout',0.2))
— El valor predeterminado es .'Learners'
'linear'
Puede especificar , , a u objeto, o una matriz de celdas de dichos objetos.'linear'
'kernel'
templateLinear
templateKernel
— Cuando se utilizan alumnos binarios lineales, el valor del hiperparámetro debe ser .'OptimizeHyperparameters'
'Regularization'
'ridge'
'Prior'
— El valor predeterminado es .'Verbose'
1
'Weights'
Este argumento de par nombre-valor adicional es específico de matrices altas:
— Un escalar entero positivo que especifica el número de alumnos binarios que se entrenan simultáneamente mediante la combinación de operaciones de E/S de archivos.'NumConcurrent'
El valor predeterminado para es , lo que significa que entrena a los alumnos binarios secuencialmente. es más beneficioso cuando las matrices de entrada no caben en la memoria del clúster distribuido.'NumConcurrent'
1
fitcecoc
'NumConcurrent'
De lo contrario, las matrices de entrada se pueden almacenar en caché y la aceleración es insignificante.
Si ejecuta el código en , está limitado por la memoria disponible para las comunicaciones.Apache Spark™NumConcurrent
Compruebe las propiedades y en la configuración.'spark.executor.memory'
'spark.driver.memory'
Apache Spark Consulte para obtener más detalles.parallel.cluster.Hadoop
(Parallel Computing Toolbox) Para obtener más información sobre y otros entornos de ejecución que controlan dónde se ejecuta el código, vea .Apache SparkExtend Tall Arrays with Other Products
Para obtener más información, consulte .Arreglos altos
Para ejecutar en paralelo, establezca la opción en una de estas maneras:'UseParallel'
true
Establezca el campo de la estructura de opciones en using y especifique el argumento de par nombre-valor en la llamada a .'UseParallel'
true
statset
'Options'
fitceoc
Por ejemplo:'Options',statset('UseParallel',true)
Para obtener más información, consulte el argumento de par nombre-valor.'Options'
Realice la optimización de hiperparámetros paralelos mediante el argumento de par nombre-valor en la llamada a .'HyperparameterOptions',struct('UseParallel',true)
fitceoc
Para obtener más información sobre la optimización de hiperparámetros paralelos, consulte .Parallel Bayesian Optimization
ClassificationECOC
| ClassificationPartitionedECOC
| ClassificationPartitionedKernelECOC
| ClassificationPartitionedLinearECOC
| CompactClassificationECOC
| designecoc
| loss
| predict
| statset
Existe una versión modificada de este ejemplo en su sistema. ¿Prefiere abrir esta versión?
Ha hecho clic en un enlace que corresponde a este comando de MATLAB:
Ejecute el comando introduciéndolo en la ventana de comandos de MATLAB. Los navegadores web no admiten comandos de MATLAB.
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:
Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.