Decision Tree Classifier

new DecisionTreeTextClassifier(options?: {
  maxDepth?: number;
  minSamples?: number;
  maxCandidateFeatures?: number;
  maxFeatures?: number;
})

import { DecisionTreeTextClassifier } from "bun_nltk";

const classifier = new DecisionTreeTextClassifier({
  maxDepth: 10,
  minSamples: 5,
  maxFeatures: 8000,
});

train(examples: DecisionTreeExample[]): this

classifier.train([
  { label: "positive", text: "Great service and fast delivery" },
  { label: "negative", text: "Poor quality, not worth the price" },
  { label: "positive", text: "Excellent product, highly satisfied" },
]);

classify(text: string): string

const label = classifier.classify("Amazing quality and value");
console.log(label); // "positive"

predict(text: string): Array<{ label: string; score: number }>

const predictions = classifier.predict("Disappointing experience");
console.log(predictions);
// [
//   { label: "negative", score: 1 },
//   { label: "positive", score: 0 }
// ]

evaluate(examples: DecisionTreeExample[]): {
  accuracy: number;
  total: number;
  correct: number;
}

const results = classifier.evaluate(testData);
console.log(`Accuracy: ${(results.accuracy * 100).toFixed(1)}%`);
console.log(`Correct: ${results.correct}/${results.total}`);

toJSON(): DecisionTreeSerialized

const modelData = classifier.toJSON();
await Bun.write("tree-model.json", JSON.stringify(modelData));

static fromJSON(payload: DecisionTreeSerialized): DecisionTreeTextClassifier

const data = await Bun.file("tree-model.json").json();
const classifier = DecisionTreeTextClassifier.fromJSON(data);

trainDecisionTreeTextClassifier(
  examples: DecisionTreeExample[],
  options?: {
    maxDepth?: number;
    minSamples?: number;
    maxCandidateFeatures?: number;
    maxFeatures?: number;
  }
): DecisionTreeTextClassifier

import { trainDecisionTreeTextClassifier } from "bun_nltk";

const classifier = trainDecisionTreeTextClassifier(
  [
    { label: "question", text: "How do I reset my password?" },
    { label: "complaint", text: "Service is down again" },
    { label: "question", text: "What are your business hours?" },
  ],
  { maxDepth: 8, maxFeatures: 5000 }
);

loadDecisionTreeTextClassifier(
  payload: DecisionTreeSerialized
): DecisionTreeTextClassifier

import { loadDecisionTreeTextClassifier } from "bun_nltk";

const data = await Bun.file("tree-model.json").json();
const classifier = loadDecisionTreeTextClassifier(data);

type DecisionTreeExample = {
  label: string;
  text: string;
};

type DecisionTreeSerialized = {
  version: number;
  labels: string[];
  options: {
    maxDepth: number;
    minSamples: number;
    maxCandidateFeatures: number;
  };
  vectorizer: VectorizerSerialized;
  tree: DecisionTreeNodeSerialized;
};

import {
  trainDecisionTreeTextClassifier,
  loadDecisionTreeTextClassifier,
} from "bun_nltk";

// Training data
const trainingData = [
  { label: "urgent", text: "Critical bug in production system" },
  { label: "normal", text: "Update documentation for API" },
  { label: "urgent", text: "Database connection failing" },
  { label: "low", text: "Improve button styling" },
  { label: "normal", text: "Add unit tests for utils" },
  { label: "urgent", text: "Security vulnerability detected" },
];

// Train with custom settings
const classifier = trainDecisionTreeTextClassifier(trainingData, {
  maxDepth: 6,
  minSamples: 2,
  maxFeatures: 3000,
});

// Classify new tickets
const ticket = "Server is not responding to requests";
const priority = classifier.classify(ticket);
console.log(`Priority: ${priority}`); // "urgent"

// Get detailed predictions
const predictions = classifier.predict(ticket);
console.log(predictions);

// Evaluate accuracy
const testData = [
  { label: "urgent", text: "Application crashed" },
  { label: "low", text: "Update footer text" },
];
const metrics = classifier.evaluate(testData);
console.log(`Accuracy: ${(metrics.accuracy * 100).toFixed(1)}%`);

// Save and load model
const modelData = classifier.toJSON();
await Bun.write("decision-tree.json", JSON.stringify(modelData));

const loaded = loadDecisionTreeTextClassifier(
  await Bun.file("decision-tree.json").json()
);
console.log(loaded.classify("Fix broken link")); // Uses loaded model