BaggingClassifier trains multiple base estimators on random subsets of the dataset.
Constructor
import { BaggingClassifier } from 'scikitjs';
const bagging = new BaggingClassifier(estimatorFactory, options);
estimatorFactory
estimator | () => estimator
required
Base estimator to fit on random subsets. Can be an instance or factory function.
Number of base estimators in the ensemble.
Number of samples to draw:
- If int, draw
maxSamples samples
- If float, draw
maxSamples * nSamples samples
Number of features to draw:
- If int, draw
maxFeatures features
- If float, draw
maxFeatures * nFeatures features
Whether samples are drawn with replacement.
options.bootstrapFeatures
Whether features are drawn with replacement.
Random seed for reproducibility.
Methods
fit
Fit the bagging ensemble.
fit(X: number[][], y: number[], sampleWeight?: number[]): BaggingClassifier
predict
Predict class labels using majority voting.
predict(X: number[][]): number[]
predictProba
Predict class probabilities.
predictProba(X: number[][]): number[][]
score
Return accuracy score.
score(X: number[][], y: number[]): number
Properties
The fitted base estimators
The feature indices used by each estimator
Examples
Basic Bagging
import { BaggingClassifier, DecisionTreeClassifier } from 'scikitjs';
const X = [
[1, 2], [2, 3], [3, 4], [4, 5],
[5, 6], [6, 7], [7, 8], [8, 9]
];
const y = [0, 0, 0, 0, 1, 1, 1, 1];
// Create bagging ensemble with decision trees
const bagging = new BaggingClassifier(
() => new DecisionTreeClassifier(),
{ nEstimators: 10, randomState: 42 }
);
bagging.fit(X, y);
const predictions = bagging.predict([[3.5, 4.5], [6.5, 7.5]]);
console.log(predictions); // [0, 1]
const probabilities = bagging.predictProba([[3.5, 4.5]]);
console.log(probabilities); // [[0.8, 0.2]]
Subsample Features
import { BaggingClassifier, DecisionTreeClassifier } from 'scikitjs';
const X = [
[1, 2, 3, 4], [2, 3, 4, 5],
[3, 4, 5, 6], [4, 5, 6, 7]
];
const y = [0, 0, 1, 1];
// Use random feature subsets
const bagging = new BaggingClassifier(
() => new DecisionTreeClassifier(),
{
nEstimators: 10,
maxFeatures: 0.5, // Use 50% of features
randomState: 42
}
);
bagging.fit(X, y);
Control Sample Size
import { BaggingClassifier, KNeighborsClassifier } from 'scikitjs';
const X = [
[1, 2], [2, 3], [3, 4], [4, 5],
[5, 6], [6, 7], [7, 8], [8, 9]
];
const y = [0, 0, 0, 0, 1, 1, 1, 1];
// Use 80% of samples for each estimator
const bagging = new BaggingClassifier(
() => new KNeighborsClassifier({ nNeighbors: 3 }),
{
nEstimators: 20,
maxSamples: 0.8,
bootstrap: true,
randomState: 42
}
);
bagging.fit(X, y);
Without Replacement (Pasting)
import { BaggingClassifier, DecisionTreeClassifier } from 'scikitjs';
// Pasting: bootstrap=false means sampling without replacement
const pasting = new BaggingClassifier(
() => new DecisionTreeClassifier(),
{
nEstimators: 10,
maxSamples: 0.7,
bootstrap: false, // No replacement
randomState: 42
}
);
pasting.fit(X, y);
Random Subspaces
import { BaggingClassifier, DecisionTreeClassifier } from 'scikitjs';
// Random subspaces: sample features without replacement
const randomSubspaces = new BaggingClassifier(
() => new DecisionTreeClassifier(),
{
nEstimators: 10,
maxFeatures: 0.5,
bootstrapFeatures: false, // Sample features without replacement
randomState: 42
}
);
randomSubspaces.fit(X, y);
Random Patches
import { BaggingClassifier, DecisionTreeClassifier } from 'scikitjs';
// Random patches: sample both samples and features
const randomPatches = new BaggingClassifier(
() => new DecisionTreeClassifier(),
{
nEstimators: 10,
maxSamples: 0.8,
maxFeatures: 0.8,
bootstrap: true,
bootstrapFeatures: true,
randomState: 42
}
);
randomPatches.fit(X, y);
Out-of-Bag Score Estimation
import { BaggingClassifier, DecisionTreeClassifier } from 'scikitjs';
const bagging = new BaggingClassifier(
() => new DecisionTreeClassifier(),
{
nEstimators: 50,
maxSamples: 0.8,
bootstrap: true,
randomState: 42
}
);
bagging.fit(XTrain, yTrain);
// Use separate test set for evaluation
const testScore = bagging.score(XTest, yTest);
console.log('Test score:', testScore);
Reduce Overfitting
import {
BaggingClassifier,
DecisionTreeClassifier,
trainTestSplit
} from 'scikitjs';
const X = /* your data */;
const y = /* your labels */;
const [XTrain, XTest, yTrain, yTest] = trainTestSplit(X, y, {
testSize: 0.3,
randomState: 42
});
// Single decision tree (prone to overfitting)
const singleTree = new DecisionTreeClassifier();
singleTree.fit(XTrain, yTrain);
console.log('Single tree:', singleTree.score(XTest, yTest));
// Bagging ensemble (reduces overfitting)
const bagging = new BaggingClassifier(
() => new DecisionTreeClassifier(),
{ nEstimators: 50, randomState: 42 }
);
bagging.fit(XTrain, yTrain);
console.log('Bagging:', bagging.score(XTest, yTest));
Inspect Individual Estimators
import { BaggingClassifier, DecisionTreeClassifier } from 'scikitjs';
const bagging = new BaggingClassifier(
() => new DecisionTreeClassifier(),
{ nEstimators: 10, randomState: 42 }
);
bagging.fit(X, y);
// Access individual estimators
for (let i = 0; i < bagging.estimators_.length; i++) {
const estimator = bagging.estimators_[i];
const features = bagging.estimatorsFeatures_[i];
console.log(`Estimator ${i}:`);
console.log(' Features used:', features);
console.log(' Tree depth:', estimator.getDepth?.());
}
Parallel Diversity
import {
BaggingClassifier,
LogisticRegression,
DecisionTreeClassifier,
KNeighborsClassifier
} from 'scikitjs';
// Bagging with different base estimators
const models = [
new BaggingClassifier(() => new LogisticRegression(), { nEstimators: 10 }),
new BaggingClassifier(() => new DecisionTreeClassifier(), { nEstimators: 10 }),
new BaggingClassifier(() => new KNeighborsClassifier(), { nEstimators: 10 })
];
for (const model of models) {
model.fit(XTrain, yTrain);
console.log(model.constructor.name, model.score(XTest, yTest));
}