Maximum Entropy Classifier

new MaxEntTextClassifier(options?: {
  epochs?: number;
  learningRate?: number;
  l2?: number;
  maxFeatures?: number;
})

import { MaxEntTextClassifier } from "bun_nltk";

const classifier = new MaxEntTextClassifier({
  epochs: 30,
  learningRate: 0.1,
  l2: 5e-4,
  maxFeatures: 10000,
});

train(examples: MaxEntExample[]): this

classifier.train([
  { label: "weather", text: "It's sunny and warm today" },
  { label: "greeting", text: "Hello, how are you?" },
  { label: "weather", text: "Rain expected this afternoon" },
  { label: "farewell", text: "Goodbye, see you later" },
]);

classify(text: string): string

const label = classifier.classify("The forecast shows clouds");
console.log(label); // "weather"

predict(text: string): MaxEntPrediction[]

const predictions = classifier.predict("Hi there!");
console.log(predictions);
// [
//   { label: "greeting", probability: 0.82, logit: 1.58 },
//   { label: "farewell", probability: 0.11, logit: -0.73 },
//   { label: "weather", probability: 0.07, logit: -1.12 }
// ]

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

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

labelsList(): string[]

const labels = classifier.labelsList();
console.log(labels); // ["farewell", "greeting", "weather"]

toJSON(): MaxEntSerialized

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

static fromSerialized(payload: MaxEntSerialized): MaxEntTextClassifier

const data = await Bun.file("maxent-model.json").json();
const classifier = MaxEntTextClassifier.fromSerialized(data);

trainMaxEntTextClassifier(
  examples: MaxEntExample[],
  options?: {
    epochs?: number;
    learningRate?: number;
    l2?: number;
    maxFeatures?: number;
  }
): MaxEntTextClassifier

import { trainMaxEntTextClassifier } from "bun_nltk";

const classifier = trainMaxEntTextClassifier(
  [
    { label: "bug", text: "Application crashes on startup" },
    { label: "feature", text: "Add dark mode support" },
    { label: "question", text: "How do I configure settings?" },
    { label: "bug", text: "Error message displays incorrectly" },
  ],
  {
    epochs: 30,
    learningRate: 0.12,
    maxFeatures: 8000,
  }
);

loadMaxEntTextClassifier(
  payload: MaxEntSerialized
): MaxEntTextClassifier

import { loadMaxEntTextClassifier } from "bun_nltk";

const data = await Bun.file("maxent-model.json").json();
const classifier = loadMaxEntTextClassifier(data);

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

type MaxEntPrediction = {
  label: string;
  probability: number; // Softmax probability (0-1)
  logit: number;       // Raw score before softmax
};

type MaxEntSerialized = {
  version: number;
  labels: string[];
  vocabulary: string[];
  weights: number[][];  // [numLabels][vocabSize]
  bias: number[];       // [numLabels]
  options: {
    epochs: number;
    learningRate: number;
    l2: number;
    maxFeatures: number;
  };
};

import {
  trainMaxEntTextClassifier,
  loadMaxEntTextClassifier,
} from "bun_nltk";

// Training data for intent classification
const trainingData = [
  { label: "book_flight", text: "I want to book a flight to Paris" },
  { label: "cancel_booking", text: "Cancel my reservation please" },
  { label: "check_status", text: "What's the status of my order?" },
  { label: "book_flight", text: "Reserve a ticket to London tomorrow" },
  { label: "cancel_booking", text: "I need to cancel my appointment" },
  { label: "check_status", text: "Where is my package?" },
  { label: "book_flight", text: "Schedule a flight for next week" },
  { label: "cancel_booking", text: "Remove my booking" },
];

// Train with custom hyperparameters
const classifier = trainMaxEntTextClassifier(trainingData, {
  epochs: 40,
  learningRate: 0.2,
  l2: 1e-4,
  maxFeatures: 5000,
});

// Classify user input
const userText = "I'd like to fly to Tokyo";
const intent = classifier.classify(userText);
console.log(`Detected intent: ${intent}`); // "book_flight"

// Get confidence scores
const predictions = classifier.predict(userText);
for (const pred of predictions) {
  console.log(
    `${pred.label}: ${(pred.probability * 100).toFixed(1)}% (logit: ${pred.logit.toFixed(2)})`
  );
}
// Output:
// book_flight: 87.3% (logit: 1.94)
// check_status: 8.2% (logit: -0.68)
// cancel_booking: 4.5% (logit: -1.23)

// Evaluate on test set
const testData = [
  { label: "book_flight", text: "Get me a plane ticket" },
  { label: "cancel_booking", text: "Delete my reservation" },
  { label: "check_status", text: "Track my order" },
];

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

// Check available labels
const labels = classifier.labelsList();
console.log(`Trained on ${labels.length} intents:`, labels);

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

// Load model later
const loadedData = await Bun.file("intent-classifier.json").json();
const loadedClassifier = loadMaxEntTextClassifier(loadedData);
console.log(loadedClassifier.classify("Book a flight for me"));
// "book_flight"