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.

fitcensemble

Ajuste conjunto de estudiantes para la clasificación

Descripción

ejemplo

Mdl = fitcensemble(Tbl,ResponseVarName) Devuelve el modelo de conjunto de clasificación entrenado Object () que contiene los resultados de aumentar 100 árboles de clasificación y los datos de predicción y respuesta en la tabla. es el nombre de la variable de respuesta en.MdlTblResponseVarNameTbl De forma predeterminada, fitcensemble utiliza LogitBoost para la clasificación binaria y AdaBoostM2 para la clasificación multiclase.

ejemplo

Mdl = fitcensemble(Tbl,formula) se aplica para ajustar el modelo a los datos de predicción y respuesta de la tabla. es un modelo explicativo de la respuesta y un subconjunto de variables predictoras en uso para ajustarse.FórmulaTblFórmulaTblMdl Por ejemplo, se ajusta a la variable de respuesta como una función de las variables predictoras y.'Y~X1+X2+X3'Tbl.YTbl.X1Tbl.X2Tbl.X3

ejemplo

Mdl = fitcensemble(Tbl,Y) trata todas las variables de la tabla como variables predictoras. es la matriz de etiquetas de clase que no está en.TblYTbl

ejemplo

Mdl = fitcensemble(X,Y) utiliza los Datos predictores en la matriz y la matriz de etiquetas de clase en.XY

ejemplo

Mdl = fitcensemble(___,Name,Value) utiliza opciones adicionales especificadas por uno o más argumentos de par y cualquiera de los argumentos de entrada en las sintaxis anteriores.Name,Value Por ejemplo, puede especificar el número de ciclos de aprendizaje, el método de agregación de conjunto o implementar la validación cruzada de 10 veces.

Ejemplos

contraer todo

Cree un conjunto de clasificación predictiva utilizando todas las variables predictoras disponibles en los datos. Luego, entrena a otro conjunto usando menos predictores. Compare las precisiones predictivas en la muestra de los conjuntos.

Cargue el conjunto de datos.census1994

load census1994

Entrenar un conjunto de modelos de clasificación utilizando todo el conjunto de datos y las opciones predeterminadas.

Mdl1 = fitcensemble(adultdata,'salary')
Mdl1 =    classreg.learning.classif.ClassificationEnsemble            PredictorNames: {1x14 cell}              ResponseName: 'salary'     CategoricalPredictors: [2 4 6 7 8 9 10 14]                ClassNames: [<=50K    >50K]            ScoreTransform: 'none'           NumObservations: 32561                NumTrained: 100                    Method: 'LogitBoost'              LearnerNames: {'Tree'}      ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'                   FitInfo: [100x1 double]        FitInfoDescription: {2x1 cell}     Properties, Methods  

es un modelo.MdlClassificationEnsemble Algunas características notables de son:Mdl

  • Dado que dos clases se representan en los datos, LogitBoost es el algoritmo de agregación de conjunto.

  • Dado que el método de agregación de conjunto es un algoritmo de aumento, los árboles de clasificación que permiten un máximo de 10 divisiones componen el conjunto.

  • 100 árboles componen el conjunto.

Utilice el conjunto de clasificación para predecir las etiquetas de un conjunto aleatorio de cinco observaciones de los datos. Compare las etiquetas previstas con sus valores verdaderos.

rng(1) % For reproducibility [pX,pIdx] = datasample(adultdata,5); label = predict(Mdl1,pX); table(label,adultdata.salary(pIdx),'VariableNames',{'Predicted','Truth'})
ans=5×2 table
    Predicted    Truth
    _________    _____

      <=50K      <=50K
      <=50K      <=50K
      <=50K      <=50K
      <=50K      <=50K
      <=50K      <=50K

Entrena un nuevo conjunto usando y sólo.ageeducation

Mdl2 = fitcensemble(adultdata,'salary ~ age + education');

Compare las pérdidas de reenvío entre y.Mdl1Mdl2

rsLoss1 = resubLoss(Mdl1)
rsLoss1 = 0.1058 
rsLoss2 = resubLoss(Mdl2)
rsLoss2 = 0.2037 

La tasa de clasificación errónea en la muestra para el conjunto que utiliza todos los predictores es menor.

Entrena un conjunto de árboles de clasificación potenciado usando.fitcensemble Reduzca el tiempo de entrenamiento especificando el argumento de par nombre-valor para los predictores numéricos de bin.'NumBins' Este argumento sólo es válido cuando se utiliza un aprendiz de árbol.fitcensemble Después del entrenamiento, puede reproducir datos de predictor en bin utilizando la propiedad del modelo entrenado y la función.BinEdgesdiscretize

Genere un conjunto de datos de ejemplo.

rng('default') % For reproducibility N = 1e6; X = [mvnrnd([-1 -1],eye(2),N); mvnrnd([1 1],eye(2),N)]; y = [zeros(N,1); ones(N,1)];

Visualice el conjunto de datos.

figure scatter(X(1:N,1),X(1:N,2),'Marker','.','MarkerEdgeAlpha',0.01) hold on scatter(X(N+1:2*N,1),X(N+1:2*N,2),'Marker','.','MarkerEdgeAlpha',0.01)

Entrenar un conjunto de árboles de clasificación potenciado mediante la regresión logística adaptable (, el valor predeterminado para la clasificación binaria).LogitBoost Tiempo de la función para fines de comparación.

tic Mdl1 = fitcensemble(X,y); toc
Elapsed time is 478.988422 seconds. 

Acelere el entrenamiento mediante el argumento de par nombre-valor.'NumBins' Si especifica el valor como un escalar entero positivo, las ubicaciones de software cada predictor numérico en un número especificado de bins equiprobables y, a continuación, crece árboles en los índices de ubicación en lugar de los datos originales.'NumBins' El software no bin predictores categóricos.

tic Mdl2 = fitcensemble(X,y,'NumBins',50); toc
Elapsed time is 165.598434 seconds. 

El proceso es aproximadamente tres veces más rápido cuando se utilizan datos binned en lugar de los datos originales. Tenga en cuenta que el tiempo transcurrido puede variar en función del sistema operativo.

Compare los errores de clasificación por reenvío.

rsLoss1 = resubLoss(Mdl1)
rsLoss1 = 0.0788 
rsLoss2 = resubLoss(Mdl2)
rsLoss2 = 0.0788 

En este ejemplo, los valores predictores de discretización reducen el tiempo de entrenamiento sin pérdida de precisión. En general, cuando tiene un conjunto de datos grande como el de este ejemplo, el uso de la opción de discretización acelera el entrenamiento, pero provoca una posible disminución de la precisión. Si desea reducir aún más el tiempo de entrenamiento, especifique un número menor de bins.

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

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

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

Estime el error de generalización del conjunto de árboles de clasificación potenciado.

Cargue el conjunto de datos.ionosphere

load ionosphere

Valide de forma cruzada un conjunto de árboles de clasificación mediante AdaBoostM1 y validación cruzada de 10 veces. Especifique que cada árbol debe dividirse un máximo de cinco veces utilizando una plantilla de árbol de decisión.

rng(5); % For reproducibility t = templateTree('MaxNumSplits',5); Mdl = fitcensemble(X,Y,'Method','AdaBoostM1','Learners',t,'CrossVal','on');

es un modelo.MdlClassificationPartitionedEnsemble

Trace el índice acumulativo, 10 veces de validación cruzada y de clasificación errónea. Muestra el error de generalización estimado del conjunto.

kflc = kfoldLoss(Mdl,'Mode','cumulative'); figure; plot(kflc); ylabel('10-fold Misclassification rate'); xlabel('Learning cycle');

 estGenError = kflc(end)
estGenError = 0.0712 

Devuelve el error de generalización de forma predeterminada.kfoldLoss Sin embargo, trazar la pérdida acumulada le permite monitorear cómo la pérdida cambia a medida que los estudiantes débiles se acumulan en el conjunto.

El conjunto logra una tasa de clasificación errónea de alrededor de 0,06 después de acumular alrededor de 50 estudiantes débiles. Entonces, la tasa de clasificación errónea aumenta ligeramente a medida que los alumnos más débiles entran en el conjunto.

Si está satisfecho con el error de generalización del conjunto, a continuación, para crear un modelo predictivo, entrenar el conjunto de nuevo utilizando todas las configuraciones excepto la validación cruzada. Sin embargo, es una buena práctica ajustar los hiperparámetros, como el número máximo de divisiones de decisión por árbol y el número de ciclos de aprendizaje.

Optimice los hiperparámetros automáticamente mediante.fitcensemble

Cargue el conjunto de datos.ionosphere

load ionosphere

Puede encontrar hiperparámetros que minimicen la pérdida de la validación cruzada de cinco veces mediante la optimización automática del hiperparámetro.

Mdl = fitcensemble(X,Y,'OptimizeHyperparameters','auto') 

En este ejemplo, para la reproducibilidad, establezca la semilla aleatoria y utilice la función de adquisición.'expected-improvement-plus' Además, para la reproducibilidad del algoritmo de bosque aleatorio, especifique el argumento de par nombre-valor como para los alumnos de árbol.'Reproducible'true

rng('default') t = templateTree('Reproducible',true); Mdl = fitcensemble(X,Y,'OptimizeHyperparameters','auto','Learners',t, ...     'HyperparameterOptimizationOptions',struct('AcquisitionFunctionName','expected-improvement-plus'))

|===================================================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |       Method | NumLearningC-|    LearnRate |  MinLeafSize | |      | result |             | runtime     | (observed)  | (estim.)    |              | ycles        |              |              | |===================================================================================================================================| |    1 | Best   |     0.10256 |      3.3624 |     0.10256 |     0.10256 |     RUSBoost |           11 |     0.010199 |           17 | |    2 | Best   |    0.062678 |      9.6203 |    0.062678 |    0.064264 |   LogitBoost |          206 |      0.96537 |           33 | |    3 | Accept |    0.099715 |      8.0898 |    0.062678 |    0.062688 |   AdaBoostM1 |          130 |    0.0072814 |            2 | |    4 | Accept |    0.065527 |      1.6408 |    0.062678 |    0.062681 |          Bag |           25 |            - |            5 | |    5 | Accept |    0.065527 |      7.7597 |    0.062678 |    0.062695 |   LogitBoost |          178 |      0.52008 |           40 | |    6 | Accept |    0.068376 |      5.9989 |    0.062678 |    0.062693 |  GentleBoost |          146 |      0.46233 |            8 | |    7 | Accept |    0.076923 |      18.779 |    0.062678 |    0.063613 |  GentleBoost |          456 |    0.0018323 |            3 | |    8 | Accept |    0.068376 |      22.404 |    0.062678 |    0.063878 |   LogitBoost |          479 |     0.036176 |            7 | |    9 | Accept |    0.068376 |      11.182 |    0.062678 |    0.065468 |   LogitBoost |          277 |      0.99964 |           42 | |   10 | Accept |     0.17379 |     0.56157 |    0.062678 |    0.064692 |   LogitBoost |           11 |    0.0012008 |            1 | |   11 | Accept |    0.065527 |      5.5375 |    0.062678 |    0.064854 |          Bag |          100 |            - |            1 | |   12 | Accept |    0.076923 |      1.0801 |    0.062678 |    0.062571 |  GentleBoost |           23 |    0.0096328 |            2 | |   13 | Accept |    0.082621 |     0.80043 |    0.062678 |    0.064919 |  GentleBoost |           18 |    0.0078878 |           61 | |   14 | Accept |    0.065527 |      27.031 |    0.062678 |     0.06557 |          Bag |          499 |            - |            7 | |   15 | Accept |    0.079772 |      15.974 |    0.062678 |    0.064962 |  GentleBoost |          359 |     0.080649 |            1 | |   16 | Accept |     0.35897 |     0.59864 |    0.062678 |    0.062491 |          Bag |           10 |            - |          171 | |   17 | Accept |     0.35897 |     0.76429 |    0.062678 |    0.062483 |   AdaBoostM1 |           14 |    0.0029975 |          174 | |   18 | Accept |     0.10826 |       33.38 |    0.062678 |    0.062484 |     RUSBoost |          498 |      0.35355 |            1 | |   19 | Accept |     0.64103 |      1.3341 |    0.062678 |    0.062469 |     RUSBoost |           20 |      0.11564 |          175 | |   20 | Accept |    0.091168 |       12.13 |    0.062678 |    0.062474 |     RUSBoost |          187 |    0.0010337 |            5 | |===================================================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   |       Method | NumLearningC-|    LearnRate |  MinLeafSize | |      | result |             | runtime     | (observed)  | (estim.)    |              | ycles        |              |              | |===================================================================================================================================| |   21 | Accept |    0.076923 |      14.191 |    0.062678 |    0.062473 |  GentleBoost |          322 |     0.020651 |          174 | |   22 | Accept |    0.065527 |      3.9125 |    0.062678 |    0.062473 |   AdaBoostM1 |           63 |      0.94968 |            1 | |   23 | Accept |     0.17379 |      7.1762 |    0.062678 |    0.062356 |   LogitBoost |          166 |    0.0011034 |          175 | |   24 | Accept |     0.17379 |     0.93764 |    0.062678 |    0.062611 |   LogitBoost |           20 |    0.0011381 |           15 | |   25 | Accept |    0.062678 |      5.5353 |    0.062678 |    0.062619 |   LogitBoost |          125 |       0.9709 |            4 | |   26 | Accept |     0.11681 |      0.7908 |    0.062678 |    0.062621 |     RUSBoost |           10 |      0.93628 |            6 | |   27 | Accept |    0.082621 |      1.0245 |    0.062678 |    0.062716 |  GentleBoost |           19 |      0.94744 |           75 | |   28 | Accept |    0.065527 |      6.1532 |    0.062678 |    0.064168 |   LogitBoost |          131 |      0.99024 |            9 | |   29 | Accept |    0.068376 |      26.654 |    0.062678 |    0.064254 |          Bag |          489 |            - |            2 | |   30 | Accept |    0.076923 |       19.52 |    0.062678 |    0.063851 |  GentleBoost |          458 |    0.0010094 |           16 |  __________________________________________________________ Optimization completed. MaxObjectiveEvaluations of 30 reached. Total function evaluations: 30 Total elapsed time: 319.7864 seconds. Total objective function evaluation time: 273.9233  Best observed feasible point:       Method      NumLearningCycles    LearnRate    MinLeafSize     __________    _________________    _________    ___________      LogitBoost           206            0.96537         33       Observed objective function value = 0.062678 Estimated objective function value = 0.063851 Function evaluation time = 9.6203  Best estimated feasible point (according to models):       Method      NumLearningCycles    LearnRate    MinLeafSize     __________    _________________    _________    ___________      LogitBoost           277            0.99964         42       Estimated objective function value = 0.063851 Estimated function evaluation time = 11.6541 
Mdl =    classreg.learning.classif.ClassificationEnsemble                          ResponseName: 'Y'                 CategoricalPredictors: []                            ClassNames: {'b'  'g'}                        ScoreTransform: 'none'                       NumObservations: 351     HyperparameterOptimizationResults: [1×1 BayesianOptimization]                            NumTrained: 277                                Method: 'LogitBoost'                          LearnerNames: {'Tree'}                  ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'                               FitInfo: [277×1 double]                    FitInfoDescription: {2×1 cell}     Properties, Methods  

La optimización buscó en los métodos de agregación de conjuntos para la clasificación binaria, sobre, sobre el para los métodos aplicables y sobre el aprendiz de árbol.NumLearningCyclesLearnRateMinLeafSize La salida es el clasificador de conjunto con la pérdida de validación cruzada mínima estimada.

Una forma de crear un conjunto de árboles de clasificación potenciados que tenga un rendimiento predictivo satisfactorio es ajustando el nivel de complejidad del árbol de decisión mediante la validación cruzada. Mientras busca un nivel de complejidad óptimo, ajuste la velocidad de aprendizaje para minimizar el número de ciclos de aprendizaje.

En este ejemplo se encuentran manualmente los parámetros óptimos mediante la opción de validación cruzada (el argumento de par nombre-valor) y la función.'KFold'kfoldLoss Como alternativa, puede usar el argumento de par nombre-valor para optimizar automáticamente los hiperparámetros.'OptimizeHyperparameters' Ver.Optimizar conjunto de clasificación

Cargue el conjunto de datos.ionosphere

load ionosphere

Para buscar el nivel de complejidad de árbol óptimo:

  1. Valide de forma cruzada un conjunto de conjuntos. Aumente exponencialmente el nivel de complejidad de árbol para los conjuntos subsiguientes desde el muñón de decisión (una división) hasta a lo más-1 divisiones. es el tamaño de la muestra.nn También, variar la tasa de aprendizaje para cada conjunto entre 0,1 a 1.

  2. Calcule la tasa de clasificación errónea cruzada de cada conjunto.

  3. Para el nivel de complejidad de árbol

    <math display="block">
    <mrow>
    <mi>j</mi>
    </mrow>
    </math>
    ,
    <math display="block">
    <mrow>
    <mi>j</mi>
    <mo>=</mo>
    <mn>1</mn>
    <mo>.</mo>
    <mo>.</mo>
    <mo>.</mo>
    <mi>J</mi>
    </mrow>
    </math>
    , compare la tasa de clasificación errónea acumulada, cruzada y validada de los conjuntos, conspirándolas contra el número de ciclos de aprendizaje. Trace curvas separadas para cada tasa de aprendizaje en la misma figura.

  4. Elija la curva que logre la tasa de clasificación errónea mínima y anote el ciclo de aprendizaje y la tasa de aprendizaje correspondientes.

Valide de forma cruzada un árbol de clasificación profunda y un muñón. Estos árboles de clasificación sirven como puntos de referencia.

rng(1) % For reproducibility MdlDeep = fitctree(X,Y,'CrossVal','on','MergeLeaves','off', ...     'MinParentSize',1); MdlStump = fitctree(X,Y,'MaxNumSplits',1,'CrossVal','on');

Valide de forma cruzada un conjunto de 150 árboles de clasificación potenciado mediante la validación cruzada de 5 veces. Con una plantilla de árbol, puede variar el número máximo de divisiones utilizando los valores de la secuencia

<math display="block">
<mrow>
<mo stretchy="false">{</mo>
<msup>
<mrow>
<mn>3</mn>
</mrow>
<mrow>
<mn>0</mn>
</mrow>
</msup>
<mo>,</mo>
<msup>
<mrow>
<mn>3</mn>
</mrow>
<mrow>
<mn>1</mn>
</mrow>
</msup>
<mo>,</mo>
<mo>.</mo>
<mo>.</mo>
<mo>.</mo>
<mo>,</mo>
<msup>
<mrow>
<mn>3</mn>
</mrow>
<mrow>
<mi>m</mi>
</mrow>
</msup>
<mo stretchy="false">}</mo>
</mrow>
</math>
. es tal quem
<math display="block">
<mrow>
<msup>
<mrow>
<mn>3</mn>
</mrow>
<mrow>
<mi>m</mi>
</mrow>
</msup>
</mrow>
</math>
no es mayor que-1.n Para cada variante, ajuste la velocidad de aprendizaje utilizando cada valor en el set {0,1, 0,25, 0,5, 1};

n = size(X,1); m = floor(log(n - 1)/log(3)); learnRate = [0.1 0.25 0.5 1]; numLR = numel(learnRate); maxNumSplits = 3.^(0:m); numMNS = numel(maxNumSplits); numTrees = 150; Mdl = cell(numMNS,numLR);  for k = 1:numLR     for j = 1:numMNS         t = templateTree('MaxNumSplits',maxNumSplits(j));         Mdl{j,k} = fitcensemble(X,Y,'NumLearningCycles',numTrees,...             'Learners',t,'KFold',5,'LearnRate',learnRate(k));     end end

Calcule la tasa de clasificación errónea acumulada y validada por cada conjunto y los árboles de clasificación que sirven como puntos de referencia.

kflAll = @(x)kfoldLoss(x,'Mode','cumulative'); errorCell = cellfun(kflAll,Mdl,'Uniform',false); error = reshape(cell2mat(errorCell),[numTrees numel(maxNumSplits) numel(learnRate)]); errorDeep = kfoldLoss(MdlDeep); errorStump = kfoldLoss(MdlStump);

Trace cómo se comporta la tasa de clasificación errónea con validación cruzada a medida que aumenta el número de árboles del conjunto. Trace las curvas con respecto a la tasa de aprendizaje en la misma gráfica y trace parcelas separadas para diferentes niveles de complejidad de árbol. Elija un subconjunto de niveles de complejidad de árbol para trazar.

mnsPlot = [1 round(numel(maxNumSplits)/2) numel(maxNumSplits)]; figure for k = 1:3     subplot(2,2,k)     plot(squeeze(error(:,mnsPlot(k),:)),'LineWidth',2)     axis tight     hold on     h = gca;     plot(h.XLim,[errorDeep errorDeep],'-.b','LineWidth',2)     plot(h.XLim,[errorStump errorStump],'-.r','LineWidth',2)     plot(h.XLim,min(min(error(:,mnsPlot(k),:))).*[1 1],'--k')     h.YLim = [0 0.2];         xlabel('Number of trees')     ylabel('Cross-validated misclass. rate')     title(sprintf('MaxNumSplits = %0.3g', maxNumSplits(mnsPlot(k))))     hold off end hL = legend([cellstr(num2str(learnRate','Learning Rate = %0.2f')); ...         'Deep Tree';'Stump';'Min. misclass. rate']); hL.Position(1) = 0.6;

Cada curva contiene una tasa de clasificación errónea cruzada mínima que se produce en el número óptimo de árboles en el conjunto.

Identifique el número máximo de divisiones, el número de árboles y la tasa de aprendizaje que produce la tasa de clasificación errónea más baja en general.

[minErr,minErrIdxLin] = min(error(:)); [idxNumTrees,idxMNS,idxLR] = ind2sub(size(error),minErrIdxLin);  fprintf('\nMin. misclass. rate = %0.5f',minErr)
Min. misclass. rate = 0.05413 
fprintf('\nOptimal Parameter Values:\nNum. Trees = %d',idxNumTrees);
Optimal Parameter Values: Num. Trees = 47 
fprintf('\nMaxNumSplits = %d\nLearning Rate = %0.2f\n',...     maxNumSplits(idxMNS),learnRate(idxLR))
MaxNumSplits = 3 Learning Rate = 0.25 

Cree un conjunto predictivo basado en los hiperparámetros óptimos y en todo el conjunto de entrenamiento.

tFinal = templateTree('MaxNumSplits',maxNumSplits(idxMNS)); MdlFinal = fitcensemble(X,Y,'NumLearningCycles',idxNumTrees,...     'Learners',tFinal,'LearnRate',learnRate(idxLR))
MdlFinal =    classreg.learning.classif.ClassificationEnsemble              ResponseName: 'Y'     CategoricalPredictors: []                ClassNames: {'b'  'g'}            ScoreTransform: 'none'           NumObservations: 351                NumTrained: 47                    Method: 'LogitBoost'              LearnerNames: {'Tree'}      ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'                   FitInfo: [47×1 double]        FitInfoDescription: {2×1 cell}     Properties, Methods  

es un.MdlFinalClassificationEnsemble Para predecir si un retorno de radar es bueno dado Datos predictores, puede pasar los Datos predictores y a.MdlFinalPredecir

En lugar de buscar valores óptimos manualmente mediante la opción de validación cruzada () y la función, puede usar el argumento de par nombre-valor.'KFold'kfoldLoss'OptimizeHyperparameters' Cuando se especifica, el software encuentra los parámetros óptimos automáticamente mediante la optimización bayesiana.'OptimizeHyperparameters' Los valores óptimos obtenidos mediante el uso pueden ser diferentes de los obtenidos mediante la búsqueda manual.'OptimizeHyperparameters'

mdl = fitcensemble(X,Y,'OptimizeHyperparameters',{'NumLearningCycles','LearnRate','MaxNumSplits'})

|====================================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | NumLearningC-|    LearnRate | MaxNumSplits | |      | result |             | runtime     | (observed)  | (estim.)    | ycles        |              |              | |====================================================================================================================| |    1 | Best   |     0.17379 |      6.5879 |     0.17379 |     0.17379 |          137 |     0.001364 |            3 | |    2 | Accept |     0.17379 |     0.86125 |     0.17379 |     0.17379 |           15 |     0.013089 |          144 | |    3 | Best   |    0.065527 |      1.5839 |    0.065527 |    0.065538 |           31 |      0.47201 |            2 | |    4 | Accept |    0.074074 |      16.044 |    0.065527 |    0.065549 |          340 |      0.92167 |            7 | |    5 | Accept |    0.088319 |      1.1615 |    0.065527 |    0.065562 |           20 |      0.24336 |           55 | |    6 | Accept |    0.076923 |     0.65064 |    0.065527 |    0.072693 |           11 |      0.64021 |            1 | |    7 | Accept |    0.071225 |     0.58602 |    0.065527 |    0.072095 |           10 |      0.99816 |            5 | |    8 | Accept |    0.076923 |     0.60015 |    0.065527 |    0.072986 |           10 |      0.75338 |           90 | |    9 | Accept |    0.096866 |     0.59733 |    0.065527 |     0.06506 |           10 |      0.42369 |            2 | |   10 | Best   |    0.062678 |      1.8773 |    0.062678 |    0.062667 |           37 |      0.99202 |           63 | |   11 | Accept |    0.065527 |      1.0259 |    0.062678 |    0.062575 |           19 |      0.97944 |            1 | |   12 | Best   |    0.059829 |      4.2008 |    0.059829 |    0.059766 |           86 |      0.40411 |            1 | |   13 | Best   |     0.05698 |      3.0948 |     0.05698 |    0.057382 |           63 |      0.60537 |            1 | |   14 | Accept |    0.062678 |      3.2667 |     0.05698 |    0.059783 |           69 |       0.6167 |            4 | |   15 | Accept |    0.065527 |      3.5624 |     0.05698 |    0.060842 |           76 |      0.49778 |            2 | |   16 | Accept |    0.065527 |      2.1858 |     0.05698 |    0.061283 |           44 |      0.99938 |            4 | |   17 | Accept |    0.065527 |      2.6444 |     0.05698 |    0.062047 |           55 |      0.59384 |           46 | |   18 | Accept |    0.059829 |      6.0262 |     0.05698 |    0.061494 |          128 |      0.29635 |           48 | |   19 | Accept |    0.062678 |       8.417 |     0.05698 |    0.061481 |          182 |      0.25896 |            9 | |   20 | Accept |    0.062678 |      4.8812 |     0.05698 |    0.061248 |          107 |      0.38775 |            2 | |====================================================================================================================| | Iter | Eval   | Objective   | Objective   | BestSoFar   | BestSoFar   | NumLearningC-|    LearnRate | MaxNumSplits | |      | result |             | runtime     | (observed)  | (estim.)    | ycles        |              |              | |====================================================================================================================| |   21 | Accept |     0.17379 |     0.53809 |     0.05698 |      0.0612 |           10 |    0.0010009 |           53 | |   22 | Accept |     0.17379 |     0.56404 |     0.05698 |    0.061382 |           10 |     0.051241 |            2 | |   23 | Best   |     0.05698 |      4.1022 |     0.05698 |    0.060531 |           87 |       0.3124 |            1 | |   24 | Accept |     0.05698 |      4.1749 |     0.05698 |    0.058776 |           85 |        0.259 |            5 | |   25 | Accept |    0.065527 |      4.5086 |     0.05698 |    0.059405 |           93 |      0.20081 |            4 | |   26 | Accept |     0.17379 |     0.53874 |     0.05698 |    0.059578 |           10 |    0.0035026 |            2 | |   27 | Accept |     0.17379 |      1.4021 |     0.05698 |    0.059534 |           30 |    0.0036169 |            1 | |   28 | Accept |       0.151 |      1.9551 |     0.05698 |    0.059446 |           41 |     0.028937 |            1 | |   29 | Accept |     0.17379 |      1.4866 |     0.05698 |    0.059485 |           29 |    0.0010049 |            2 | |   30 | Accept |      0.1453 |     0.55298 |     0.05698 |    0.059371 |           10 |      0.13172 |            3 |  __________________________________________________________ Optimization completed. MaxObjectiveEvaluations of 30 reached. Total function evaluations: 30 Total elapsed time: 122.1601 seconds. Total objective function evaluation time: 89.6783  Best observed feasible point:     NumLearningCycles    LearnRate    MaxNumSplits     _________________    _________    ____________             87             0.3124           1        Observed objective function value = 0.05698 Estimated objective function value = 0.059371 Function evaluation time = 4.1022  Best estimated feasible point (according to models):     NumLearningCycles    LearnRate    MaxNumSplits     _________________    _________    ____________             87             0.3124           1        Estimated objective function value = 0.059371 Estimated function evaluation time = 4.1152 
mdl =    classreg.learning.classif.ClassificationEnsemble                          ResponseName: 'Y'                 CategoricalPredictors: []                            ClassNames: {'b'  'g'}                        ScoreTransform: 'none'                       NumObservations: 351     HyperparameterOptimizationResults: [1×1 BayesianOptimization]                            NumTrained: 87                                Method: 'LogitBoost'                          LearnerNames: {'Tree'}                  ReasonForTermination: 'Terminated normally after completing the requested number of training cycles.'                               FitInfo: [87×1 double]                    FitInfoDescription: {2×1 cell}     Properties, Methods  

Argumentos de entrada

contraer todo

Datos de ejemplo utilizados para entrenar el modelo, especificado como una tabla. Cada fila de corresponde a una observación, y cada columna corresponde a una variable predictora. puede contener una columna adicional para la variable de respuesta.TblTbl No se permiten las variables de varias columnas ni matrices de celdas que no sean matrices de celdas de vectores de caracteres.

  • Si contiene la variable de respuesta y desea utilizar todas las variables restantes como predictores, a continuación, especifique la variable de respuesta mediante.TblResponseVarName

  • Si contiene la variable de respuesta, y desea utilizar un subconjunto de las variables restantes sólo como predictores, a continuación, especifique una fórmula utilizando.TblFórmula

  • Si no contiene la variable de respuesta, especifique los datos de respuesta mediante.TblY La longitud de la variable de respuesta y el número de filas de debe ser igual.Tbl

Nota

Para ahorrar memoria y tiempo de ejecución, suministro y en lugar de.XYTbl

Tipos de datos: table

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

Debe especificar como un vector de caracteres o un escalar de cadena.ResponseVarName Por ejemplo, si es la variable de respuesta, especifique as.Tbl.YResponseVarName'Y' Lo contrario fitcensemble trata todas las columnas como variables predictoras.Tbl

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

Para la clasificación, puede especificar el orden de las clases mediante el argumento de par nombre-valor.ClassNames Lo contrario fitcensemble determina el orden de la clase y lo almacena en el.Mdl.ClassNames

Tipos de datos: char | string

Modelo explicativo de la respuesta y un subconjunto de las variables predictoras, especificadas como un vector de caracteres o un escalar de cadena en el formulario.'Y~X1+X2+X3' En este formulario, representa la variable de respuesta y, y representa las variables predictoras.YX1X2X3 Las variables deben ser nombres de variable en ().TblTbl.Properties.VariableNames

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

Tipos de datos: char | string

Datos predictores, especificados como matriz numérica.

Cada fila corresponde a una observación, y cada columna corresponde a una variable predictora.

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

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

Tipos de datos: single | double

Datos de respuesta, especificados como una matriz categórica, de caracteres o de cadena, Vector lógico o numérico, o matriz de celdas de vectores de caracteres. Cada entrada es la respuesta o etiqueta para la observación en la fila correspondiente de o.YXTbl La longitud y el número de filas de o deben ser iguales.YXTbl Si la variable de respuesta es una matriz de caracteres, cada elemento debe corresponder a una fila de la matriz.

Puede especificar el orden de las clases mediante el argumento de par nombre-valor.ClassNames Lo contrario fitcensemble determina el orden de la clase y lo almacena en el.Mdl.ClassNames

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

Argumentos de par nombre-valor

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

Ejemplo: Especifica que se implemente la validación cruzada de 10 veces y que se utilice como velocidad de aprendizaje.'CrossVal','on','LearnRate',0.050,05

Nota

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

General Ensemble Options

contraer todo

Método de agregación de conjunto, especificado como el par separado por comas que consta de uno de los siguientes valores.'Method'

ValorMétodoClasificación problema de soporteArgumentos de par nombre-valor relacionados
'Bag'Agregación de bootstrap (embolsado, por ejemplo, bosque aleatorio) — si es así, utiliza el embolsado con selecciones de predictor aleatorias en cada división (bosque aleatorio) de forma predeterminada.[2]'Method''Bag'fitcensemble Para usar el embolsado sin las selecciones aleatorias, utilice alumnos de árbol cuyo valor sea o utilice alumnos de clasificador de análisis discriminantes.'NumVariablesToSample''all'Binario y multiclaseN/A
'Subspace'Subespacio aleatorioBinario y multiclaseNPredToSample
'AdaBoostM1'El Boosting adaptativoBinary OnlyLearnRate
'AdaBoostM2'El Boosting adaptativoMulticlase sóloLearnRate
'GentleBoost'La potenciación adaptable suaveBinary OnlyLearnRate
'LogitBoost'La regresión logística adaptableBinary OnlyLearnRate
'LPBoost'Impulso de programación lineal: requiereOptimization Toolbox™Binario y multiclaseMarginPrecision
'RobustBoost'Boosting robusto: requiereOptimization ToolboxBinary Only, ,RobustErrorGoalRobustMarginSigmaRobustMaxMargin
'RUSBoost'Submuestreo aleatorio impulsarBinario y multiclase,LearnRateRatioToSmallest
'TotalBoost'Refuerzo totalmente correctivo: requiereOptimization ToolboxBinario y multiclaseMarginPrecision

Puede especificar opciones de muestreo (,,) para los datos de entrenamiento cuando utilice ensacado () o Boosting (,,,,,, o).FResampleReplaceResample'Bag''TotalBoost''RUSBoost''AdaBoostM1''AdaBoostM2''GentleBoost''LogitBoost''RobustBoost''LPBoost'

Los valores predeterminados son:

  • para los problemas binarios y para los problemas multiclase si incluye solamente a los estudiantes del árbol'LogitBoost''AdaBoostM2''Learners'

  • para problemas binarios y para problemas multiclase si incluye a los estudiantes de análisis de árbol y discriminantes'AdaBoostM1''AdaBoostM2''Learners'

  • Si no incluye a los estudiantes de árbol'Subspace''Learners'

Para obtener más información sobre los algoritmos de agregación de conjuntos y ejemplos, vea, y.AlgoritmosConsejosAlgoritmos de conjuntoElija un método de agregación de conjunto aplicable

Ejemplo: 'Method','Bag'

Número de ciclos de aprendizaje de conjunto, especificados como el par separado por comas que consta de un entero positivo o.'NumLearningCycles''AllPredictorCombinations'

  • Si especifica un entero positivo, entonces, en cada ciclo de aprendizaje, el software entrena a un alumno débil para cada objeto de plantilla en.Learners Por lo tanto, el software entrena a los estudiantes.NumLearningCycles*numel(Learners)

  • Si especifica, a continuación, establezca y especifique un alumno solo para.'AllPredictorCombinations'Method'Subspace'Learners Con estos ajustes, el software entrena a los estudiantes para todas las combinaciones posibles de predictores tomados a la vez.NPredToSample Por lo tanto, el software entrena a los estudiantes.nchoosek(size(X,2),NPredToSample)

El software compone el conjunto utilizando todos los estudiantes entrenados y los almacena en.Mdl.Trained

Para obtener más información, consulte.Consejos

Ejemplo: 'NumLearningCycles',500

Tipos de datos: single | double | char | string

Estudiantes débiles para usar en el conjunto, especificados como el par separado por comas que consta de un nombre de alumno débil, un objeto de plantilla de aprendizaje débil o un vector de celda de objetos de plantilla de aprendizaje débil.'Learners'

Aprendiz débilNombre de aprendiz débilFunción de creación de objetos de plantillaAjusteMethod
El análisis discriminante'discriminant'templateDiscriminantRecomendado para'Subspace'
-vecinos más cercanosk'knn'templateKNNPor sólo'Subspace'
Árbol de decisión'tree'templateTreeTodos los métodos excepto'Subspace'

  • Nombre de alumno débil (, o): utiliza los alumnos débiles creados por una función de creación de objetos de plantilla con la configuración predeterminada.'discriminant''knn''tree'fitcensemble Por ejemplo, especificar es lo mismo que especificar.'Learner','discriminant''Learner',templateDiscriminant() Vea las páginas de la función de creación de objetos de plantilla para la configuración predeterminada de un alumno débil.

  • Objeto de plantilla de alumno débil: utiliza los alumnos débiles creados por una función de creación de objetos de plantilla.fitcensemble Use los argumentos de par nombre-valor de la función de creación de objetos de plantilla para especificar la configuración de los alumnos débiles.

  • Vector de celda de objetos de plantilla de factor débil: aumenta los alumnos por ciclo de aprendizaje (consulte).mfitcensemblemNumLearningCycles Por ejemplo, para un conjunto compuesto de dos tipos de árboles de clasificación, suministro, donde y son objetos de plantilla de árbol de clasificación devueltos por.{t1 t2}t1t2templateTree

El valor predeterminado es if.'Learners''knn''Method''Subspace'

El valor predeterminado es if o Any método de Boosting.'Learners''tree''Method''Bag' Los valores predeterminados dependen del valor de.templateTree()'Method'

  • Para los árboles de decisión en bolsas, el número máximo de divisiones de decisión () es, donde es el número de observaciones.'MaxNumSplits'n–1n El número de predictores que se seleccionen aleatoriamente para cada división () es la raíz cuadrada del número de predictores.'NumVariablesToSample' Por lo tanto, crece árboles de decisión profundos.fitcensemble Puede cultivar árboles menos profundos para reducir la complejidad del modelo o el tiempo de cálculo.

  • Para árboles de decisión impulsados, es 10 y es.'MaxNumSplits''NumVariablesToSample''all' Por lo tanto, crece árboles de decisión superficial.fitcensemble Puede cultivar árboles más profundos para una mejor precisión.

Para obtener más información sobre el número de estudiantes a entrenar, vea y.NumLearningCyclesConsejos

Ejemplo: 'Learners',templateTree('MaxNumSplits',5)

Frecuencia de impresión, especificada como el par separado por comas que consta de un entero positivo o.'NPrint''off'

Para rastrear el número de o queweak learnersPliegues fitcensemble entrenado hasta ahora, especifique un entero positivo. Es decir, si especifica el entero positivo:m

  • Sin especificar también ninguna opción de validación cruzada (por ejemplo,),CrossVal fitcensemble muestra un mensaje en la línea de comandos cada vez que completa la capacitación de los alumnos débiles.m

  • Y una opción de validación cruzada, a continuación, fitcensemble muestra un mensaje en la línea de comandos cada vez que finaliza los pliegues de entrenamiento.m

Si especifica,'off' fitcensemble no muestra un mensaje cuando finaliza la formación de los alumnos débiles.

Sugerencia

Al entrenar un conjunto de muchos alumnos débiles en un conjunto de datos de gran tamaño, especifique un entero positivo para.NPrint

Ejemplo: 'NPrint',5

Tipos de datos: single | double | char | string

Número de bins para predictores numéricos, especificados como el par separado por comas que consta de un escalar entero positivo.'NumBins' Este argumento sólo es válido cuando fitcensemble utiliza un alumno de árbol, es decir, es o bien un objeto de plantilla creado mediante el uso de.'Learner''tree'templateTree

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

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

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

    • fitcensemble no bin predictores categóricos.

Cuando se utiliza un conjunto de datos de entrenamiento de gran tamaño, esta opción de discretización acelera el entrenamiento, pero provoca una posible disminución de la precisión. Usted puede probar primero, y luego cambiar el valor dependiendo de la precisión y la velocidad de entrenamiento.'NumBins',50'NumBins'

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

Ejemplo: 'NumBins',50

Tipos de datos: single | double

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

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

La especificación es apropiada si:CategoricalPredictors

  • Es.'Learners''tree'

  • es cuando todos los predictores son categóricos.'Learners''knn'

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

Ejemplo: 'CategoricalPredictors','all'

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

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

  • Si se suministra y, a continuación, se puede utilizar para dar las variables predictoras en los nombres.XY'PredictorNames'X

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

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

  • Si usted suministra, entonces usted puede utilizar para elegir qué variables predictoras a utilizar en el entrenamiento.Tbl'PredictorNames' Es decir fitcensemble utiliza únicamente las variables predictoras y la variable de respuesta en el entrenamiento.PredictorNames

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

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

    • Es una buena práctica para especificar los predictores para el entrenamiento utilizando cualquiera o sólo.'PredictorNames'Fórmula

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

Tipos de datos: string | cell

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

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

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

Ejemplo: 'ResponseName','response'

Tipos de datos: char | string

Opciones de validación cruzada

contraer todo

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

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

Para invalidar esta configuración de validación cruzada, use uno de estos argumentos de par nombre-valor:,, o.CVPartitionHoldoutKFoldLeaveout Para crear un modelo validado de forma cruzada, puede usar un argumento de par nombre-valor de validación cruzada a la vez.

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

Ejemplo: 'Crossval','on'

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

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

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

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

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

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

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

Ejemplo: 'Holdout',0.1

Tipos de datos: double | single

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

  1. Particionar aleatoriamente los datos en sets.k

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

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

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

Ejemplo: 'KFold',5

Tipos de datos: single | double

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

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

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

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

Ejemplo: 'Leaveout','on'

Otras opciones de clasificación

contraer todo

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

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

Utilizar para:ClassNames

  • Ordene las clases durante el entrenamiento.

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

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

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

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

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

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

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

  • La estructura, entonces debe tener dos campos:S

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

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

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

Nota

fitcensemble utiliza para ajustar las probabilidades de clase previas especificadas en.CostoPrior Entonces fitcensemble utiliza las probabilidades previas ajustadas para el entrenamiento y restablece la matriz de costes a su valor predeterminado.

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

Tipos de datos: double | single | struct

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

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

Una estructura con dos campos:S

  • contiene los nombres de clase como una variable del mismo tipo que.S.ClassNamesY

  • contiene un vector de las probabilidades previas correspondientes.S.ClassProbs El software normaliza los elementos que suman.1

fitcensemble Normaliza las probabilidades previas en sumar a 1.Prior

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

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

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

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

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

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

Ejemplo: 'ScoreTransform','logit'

Tipos de datos: char | string | function_handle

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

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

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

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

Tipos de datos: double | single | char | string

Opciones de muestreo para impulsar métodos y embolsado

contraer todo

Fracción del conjunto de entrenamiento que se remuestrea para cada alumno débil, especificado como el par separado por comas y que consta de un escalar positivo en (0,1].'FResample'

Para usar, especificar o establecer en.'FResample''bag'MethodResample'on'

Ejemplo: 'FResample',0.75

Tipos de datos: single | double

Indicador que indica el muestreo con sustitución, especificado como el par separado por comas que consta de y o.'Replace''off''on'

  • Para, el software muestrea las observaciones de entrenamiento con reemplazo.'on'

  • Para, el software muestrea las observaciones de entrenamiento sin reemplazo.'off' Si se establece en, a continuación, las observaciones de software muestras de formación asumiendo pesos uniformes.Resample'on' Si también especifica un método de Boosting, el software aumenta al reponderando las observaciones.

A menos que establezca o establezca en, no tiene ningún efecto.Method'bag'Resample'on'Replace

Ejemplo: 'Replace','off'

Indicador que indica que se remuestrea, especificado como el par separado por comas que consta de y o.'Resample''off''on'

  • Si es un método de Boosting, entonces:Method

    • especifica las observaciones de formación de muestra utilizando ponderaciones actualizadas como probabilidades de muestreo multinomial.'Resample','on'

    • (valor predeterminado) especifica las observaciones de reponderación en cada iteración de aprendizaje.'Resample','off'

  • Si es así, debe serlo.Method'bag''Resample''on' El software remuestrea una fracción de las observaciones de entrenamiento (ver) con o sin reemplazo (ver).FResampleReplace

Si especifica volver a muestrear utilizando, es recomendable volver a muestrear todo el conjunto de datos.Resample Es decir, utilice el valor predeterminado de 1 para.FResample

Las opciones del método AdaBoostM1, AdaBoostM2, LogitBoost y GentleBoost

contraer todo

Velocidad de aprendizaje para la contracción, especificada como el par separado por comas que consta de un escalar numérico en el intervalo (0,1).

Para entrenar un conjunto con contracción, se establece en un valor menor que, por ejemplo, es una opción popular.LearnRate10.1 Entrenar un conjunto usando contracción requiere más iteraciones de aprendizaje, pero a menudo logra una mejor precisión.

Ejemplo: 'LearnRate',0.1

Tipos de datos: single | double

Opciones del método RUSBoost

contraer todo

Velocidad de aprendizaje para la contracción, especificada como el par separado por comas que consta de un escalar numérico en el intervalo (0,1).

Para entrenar un conjunto con contracción, se establece en un valor menor que, por ejemplo, es una opción popular.LearnRate10.1 Entrenar un conjunto usando contracción requiere más iteraciones de aprendizaje, pero a menudo logra una mejor precisión.

Ejemplo: 'LearnRate',0.1

Tipos de datos: single | double

Proporción de muestreo con respecto a la clase de menor representación, especificada como el par separado por comas consistente en un vector escalar o numérico numérico de valores positivos con una longitud igual al número de clases distintas en los datos de entrenamiento.'RatioToSmallest'

Supongamos que hay K clases en los datos de entrenamiento y la clase de menor representación tiene m observaciones de los datos de formación.

  • Si especifica el escalar numérico positivo sEntonces fitcensemble Muestras s*m observaciones de cada clase, es decir, utiliza la misma proporción de muestreo para cada clase. Para obtener más información, consulte.Algoritmos

  • Si especifica el vector numérico [s1,s2,...,sK]Entonces fitcensemble Muestras si*m observaciones de la clase i, i = 1,...,.K Los elementos de corresponden al orden de los nombres de clase especificados utilizando (ver).RatioToSmallestClassNamesConsejos

El valor predeterminado es ones(K,1), que especifica la muestra m observaciones de cada clase.

Ejemplo: 'RatioToSmallest',[2,1]

Tipos de datos: single | double

Opciones del método LPBoost y TotalBoost

contraer todo

Precisión de margen para controlar la velocidad de convergencia, especificada como el par separado por comas que consta de y un escalar numérico en el intervalo [0,1]. afecta al número de iteraciones de impulso requeridas para la convergencia.'MarginPrecision'MarginPrecision

Sugerencia

Para entrenar un conjunto con muchos alumnos, especifique un valor pequeño para.MarginPrecision Para entrenar con unos pocos alumnos, especifique un valor grande.

Ejemplo: 'MarginPrecision',0.5

Tipos de datos: single | double

Opciones del método RobustBoost

contraer todo

Error de clasificación de destino, especificado como el par separado por comas que consta de un escalar numérico no negativo.'RobustErrorGoal' El límite superior de los valores posibles depende de los valores de y.RobustMarginSigmaRobustMaxMargin Sin embargo, el límite superior no puede exceder.1

Sugerencia

Para un conjunto de entrenamiento en particular, por lo general hay un rango óptimo para.RobustErrorGoal Si lo establece demasiado bajo o demasiado alto, el software puede producir un modelo con una precisión de clasificación deficiente. Pruebe la validación cruzada para buscar el valor adecuado.

Ejemplo: 'RobustErrorGoal',0.05

Tipos de datos: single | double

Distribución del margen de clasificación distribuida en los datos de entrenamiento, especificado como el par separado por comas que consta de un escalar numérico positivo.'RobustMarginSigma' Antes de especificar, consulte la bibliografía sobre, por ejemplo,.RobustMarginSigmaRobustBoost[19]

Ejemplo: 'RobustMarginSigma',0.5

Tipos de datos: single | double

Margen de clasificación máximo en los datos de entrenamiento, especificado como el par separado por comas que consta de un escalar numérico no negativo.'RobustMaxMargin' El software minimiza el número de observaciones en los datos de entrenamiento que tienen márgenes de clasificación a continuación.RobustMaxMargin

Ejemplo: 'RobustMaxMargin',1

Tipos de datos: single | double

Opciones de método de subespacio aleatorio

contraer todo

Número de predictores que se muestra para cada alumno de subespacio aleatorio, especificado como el par separado por comas que consta de un entero positivo en el intervalo 1,...,, donde está el número de variables predictoras (o).'NPredToSample'ppsize(X,2)size(Tbl,2)

Tipos de datos: single | double

La optimización de hiperparámetros

contraer todo

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

  • — No optimice.'none'

  • — Utilice junto con los parámetros predeterminados para el especificado:'auto'{'Method','NumLearningCycles','LearnRate'}Learners

    • = (por defecto) —Learners'tree'{'MinLeafSize'}

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

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

    Nota

    Para la optimización de hiperparámetros, debe ser un único argumento, no una matriz de cadenas o una matriz de celdas.Learners

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

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

  • Vector de objetos, normalmente la salida deoptimizableVariablehiperparámetros

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

Nota

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

Los parámetros elegibles para son:fitcensemble

  • — Depende del número de clases.Method

    • Dos clases: los métodos elegibles son,,, y.'Bag''GentleBoost''LogitBoost''AdaBoostM1''RUSBoost'

    • Tres o más clases: los métodos elegibles son, y.'Bag''AdaBoostM2''RUSBoost'

  • : busca entre enteros positivos, de forma predeterminada, con escala de registro con rango.NumLearningCyclesfitcensemble[10,500]

  • — búsquedas entre reales positivos, de forma predeterminada, con escala logaritmo con rango.LearnRatefitcensemble[1e-3,1]

  • Los hiperparámetros elegibles para el elegido:Learners

    EstudiantesHiperparámetros válidos negrita = utilizado de forma predeterminada
    Rango predeterminado
    'discriminant'DeltaEscalado logaritmo en el intervalo[1e-6,1e3]
    DiscrimTypeY'linear''quadratic''diagLinear''diagQuadratic''pseudoLinear''pseudoQuadratic'
    GammaValores reales en[0,1]
    'knn'DistanceY'cityblock''chebychev''correlation''cosine''euclidean''hamming''jaccard''mahalanobis''minkowski''seuclidean''spearman'
    DistanceWeightY'equal''inverse''squaredinverse'
    ExponentLos valores positivos en[0.5,3]
    NumNeighborsLos valores enteros positivos registran la escala en el intervalo[1, max(2,round(NumObservations/2))]
    StandardizeY'true''false'
    'tree'MaxNumSplitsLos enteros registran la escala en el rango[1,max(2,NumObservations-1)]
    MinLeafSizeLos enteros registran la escala en el rango[1,max(2,floor(NumObservations/2))]
    NumVariablesToSampleLos enteros en el rango[1,max(2,NumPredictors)]
    SplitCriterionY'gdi''deviance''twoing'

    Alternativamente, utilice con su elegido.hiperparámetrosLearners Tenga en cuenta que debe especificar los Datos predictores y la respuesta al crear un objeto.optimizableVariable

    load fisheriris params = hyperparameters('fitcensemble',meas,species,'Tree');

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

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

load fisheriris params = hyperparameters('fitcensemble',meas,species,'Tree'); params(4).Range = [1,30];

Pase como el valor de.paramsOptimizeHyperparameters

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

Para ver un ejemplo, vea.Optimizar conjunto de clasificación

Ejemplo: 'OptimizeHyperparameters',{'Method','NumLearningCycles','LearnRate','MinLeafSize','MaxNumSplits'}

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

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

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

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

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

'bayesopt'
AcquisitionFunctionName

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

  • 'expected-improvement'

  • 'expected-improvement-plus'

  • 'expected-improvement-per-second'

  • 'lower-confidence-bound'

  • 'probability-of-improvement'

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

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

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

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

Mostrar en la línea de comandos.

  • — Sin visualización iterativa0

  • — Visualización iterativa1

  • — Visualización iterativa con información adicional2

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

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

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

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

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

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

Tipos de datos: struct

Argumentos de salida

contraer todo

Modelo de conjunto entrenado, devuelto como uno de los objetos del modelo de esta tabla.

Objeto de modelo¿Especificar opciones de validación cruzada?AjusteMethodAjusteResample
ClassificationBaggedEnsembleNo'Bag''on'
ClassificationEnsembleNoCualquier método de agregación de conjunto para la clasificación'off'
ClassificationPartitionedEnsembleCualquier método de agregación de conjunto para la clasificaciónO'off''on'

Los argumentos de par nombre-valor que controlan la validación cruzada son,,, y.CrossValHoldoutKFoldLeaveoutCVPartition

Para hacer referencia a las propiedades de, utilice notación de puntos.Mdl Por ejemplo, para acceder o mostrar el vector de celda de objetos de modelo de alumno débiles para un conjunto que no se ha validado de forma cruzada, escriba en la línea de comandos.Mdl.Trained

Sugerencias

  • puede variar de unas pocas docenas a unos pocos miles.NumLearningCycles Por lo general, un conjunto con buena potencia predictiva requiere de unos pocos cientos a unos pocos miles de estudiantes débiles. Sin embargo, usted no tiene que entrenar un conjunto para que muchos ciclos a la vez. Usted puede comenzar por el crecimiento de una docena de estudiantes, inspeccionar el rendimiento del conjunto y luego, si es necesario, entrenar a los estudiantes más débiles utilizando resume para los problemas de clasificación.

  • El rendimiento del conjunto depende del ajuste del conjunto y del ajuste de los alumnos débiles. Es decir, si se especifican los alumnos débiles con parámetros predeterminados, el conjunto puede tener un rendimiento deficiente. Por lo tanto, al igual que los ajustes de conjunto, es recomendable ajustar los parámetros de los alumnos débiles mediante plantillas y elegir valores que minimicen el error de generalización.

  • Si especifica volver a muestrear utilizando, es recomendable volver a muestrear todo el conjunto de datos.Resample Es decir, utilice la configuración predeterminada de for.1FResample

  • Si el método de agregación de conjunto () es y:Method'bag'

    • El costo de clasificación errónea () es altamente desequilibrado, entonces, para las muestras en bolsa, el software sobremuestrea observaciones únicas de la clase que tiene una gran penalización.Costo

    • Las probabilidades previas de clase () son altamente sesgados, el software sobremuestrea observaciones únicas de la clase que tiene una gran probabilidad previa.Prior

    Para tamaños de muestra más pequeños, estas combinaciones pueden dar lugar a una baja frecuencia relativa de observaciones fuera de bolsa de la clase que tiene una gran penalización o probabilidad previa. En consecuencia, el error de out-of-bag Estimado es muy variable y puede ser difícil de interpretar. Para evitar que se calculen grandes desviaciones de error fuera de bolsa, especialmente para tamaños de muestra pequeños, establezca una matriz de coste de clasificación errónea más equilibrada utilizando o un vector de probabilidad anterior menos sesgado.CostoPrior

  • Dado que el orden de algunos argumentos de entrada y salida corresponden a las clases distintas de los datos de entrenamiento, es recomendable especificar el orden de la clase mediante el argumento de par nombre-valor.ClassNames

    • Para determinar el orden de la clase rápidamente, quite todas las observaciones de los datos de entrenamiento que no están clasificados (es decir, tienen una etiqueta que falta), obtener y mostrar una matriz de todas las clases distintas y, a continuación, especifique la matriz para.ClassNames Por ejemplo, supongamos que la variable de respuesta () es una matriz de etiquetas de celdas.Y Este código especifica el orden de la clase en la variable. asigna a observaciones sin clasificar y excluye de su salida.classNames

      Ycat = categorical(Y); classNames = categories(Ycat)
      Categórico<undefined>categories<undefined> Por lo tanto, si usa este código para matrices de celdas de etiquetas o código similar para matrices categóricas, no tiene que quitar observaciones con etiquetas que faltan para obtener una lista de las clases distintas.

    • Para especificar que el orden de la clase de la etiqueta de menor representación a la más representada, a continuación, determinar rápidamente el orden de la clase (como en la viñeta anterior), pero organizar las clases en la lista por frecuencia antes de pasar la lista a.ClassNames A continuación del ejemplo anterior, este código especifica el orden de la clase de menor a mayor representado en.classNamesLH

      Ycat = categorical(Y); classNames = categories(Ycat); freq = countcats(Ycat); [~,idx] = sort(freq); classNamesLH = classNames(idx);

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

Algoritmos

  • Para obtener más información sobre los algoritmos de agregación de conjuntos, consulte.Algoritmos de conjunto

  • Si se establece para ser un algoritmo de impulso y ser árboles de decisión, a continuación, el software crece árboles de decisión superficial por defecto.MethodLearners Puede ajustar la profundidad del árbol especificando los argumentos de par nombre-valor y el uso.MaxNumSplitsMinLeafSizeMinParentSizetemplateTree

  • Para embolsado (),'Method','Bag' fitcensemble genera muestras en bolsa mediante las clases de sobremuestreo con grandes costos de clasificación errónea y clases de submuestreo con pequeños costos de clasificación errónea. En consecuencia, las muestras fuera de bolsa tienen menos observaciones de las clases con grandes costos de clasificación errónea y más observaciones de clases con pequeños costos de clasificación errónea. Si entrena un conjunto de clasificación utilizando un pequeño conjunto de datos y una matriz de costos altamente sesgada, entonces el número de observaciones fuera de bolsa por clase puede ser bajo. Por lo tanto, el error de out-of-bag Estimado puede tener una gran varianza y puede ser difícil de interpretar. El mismo fenómeno puede ocurrir para las clases con grandes probabilidades previas.

  • Para el método de agregación de conjunto RUSBoost (), el argumento de par nombre-valor especifica la proporción de muestreo para cada clase con respecto a la clase de menor representación.'Method','RUSBoost'RatioToSmallest Por ejemplo, supongamos que hay dos clases en los datos de entrenamiento: y. tiene 100 observaciones y tiene 10 observaciones. y que la clase con menor representación haABAB m observaciones de los datos de formación.

    • Si establece, a continuación,'RatioToSmallest',2 s*m = = .2*1020 Por consiguiente fitcensemble entrena a cada aprendiz utilizando 20 observaciones de la clase y 20 observaciones de la clase.AB Si lo establece, obtendrá el mismo resultado.'RatioToSmallest',[2 2]

    • Si establece, a continuación,'RatioToSmallest',[2,1] s1*m = = y2*1020 s2*m = = .1*1010 Por consiguiente fitcensemble entrena a cada aprendiz utilizando 20 observaciones de la clase y 10 observaciones de la clase.AB

  • Para sistemas de doble núcleo y superiores, fitcensemble paraleliza el entrenamiento mediante el uso de bloques de creación de subprocesos (TBB).Intel® Para obtener más información sobre TBB, consulte.Intelhttps://software.intel.com/en-us/intel-tbb

Referencias

[1] Breiman, L. “Bagging Predictors.” Machine Learning. Vol. 26, pp. 123–140, 1996.

[2] Breiman, L. “Random Forests.” Machine Learning. Vol. 45, pp. 5–32, 2001.

[3] Freund, Y. “A more robust boosting algorithm.” arXiv:0905.2138v1, 2009.

[4] Freund, Y. and R. E. Schapire. “A Decision-Theoretic Generalization of On-Line Learning and an Application to Boosting.” J. of Computer and System Sciences, Vol. 55, pp. 119–139, 1997.

[5] Friedman, J. “Greedy function approximation: A gradient boosting machine.” Annals of Statistics, Vol. 29, No. 5, pp. 1189–1232, 2001.

[6] Friedman, J., T. Hastie, and R. Tibshirani. “Additive logistic regression: A statistical view of boosting.” Annals of Statistics, Vol. 28, No. 2, pp. 337–407, 2000.

[7] Hastie, T., R. Tibshirani, and J. Friedman. The Elements of Statistical Learning section edition, Springer, New York, 2008.

[8] Ho, T. K. “The random subspace method for constructing decision forests.” IEEE Transactions on Pattern Analysis and Machine Intelligence, Vol. 20, No. 8, pp. 832–844, 1998.

[9] Schapire, R. E., Y. Freund, P. Bartlett, and W.S. Lee. “Boosting the margin: A new explanation for the effectiveness of voting methods.” Annals of Statistics, Vol. 26, No. 5, pp. 1651–1686, 1998.

[10] Seiffert, C., T. Khoshgoftaar, J. Hulse, and A. Napolitano. “RUSBoost: Improving classification performance when training data is skewed.” 19th International Conference on Pattern Recognition, pp. 1–4, 2008.

[11] Warmuth, M., J. Liao, and G. Ratsch. “Totally corrective boosting algorithms that maximize the margin.” Proc. 23rd Int’l. Conf. on Machine Learning, ACM, New York, pp. 1001–1008, 2006.

Capacidades ampliadas

Introducido en R2016b