Adaptive Classifier

You can load specialized, pre-trained models using AdaptiveClassifier.from_pretrained(). These are optimized for specific enterprise tasks:

• Hallucination Detection: adaptive-classifier/llm-hallucination-detector
• LLM Routing: adaptive-classifier/llm-router
• Config Optimization: adaptive-classifier/llm-config-optimizer
• Content Moderation: adaptive-classifier/content-moderation
• Business Sentiment: adaptive-classifier/business-sentiment
• PII Detection: adaptive-classifier/pii-detection
• Fraud Detection: adaptive-classifier/fraud-detection
• Email Priority: adaptive-classifier/email-priority
• Compliance Classification: adaptive-classifier/compliance-classification

# Example: Hallucination Detection
detector = AdaptiveClassifier.from_pretrained("adaptive-classifier/llm-hallucination-detector")
context = "France is in Western Europe. Capital: Paris. Population: ~67 million."
response = "Paris is the capital. Population is 70 million."

prediction = detector.predict(f"Context: {context}\nAnswer: {response}")
# Returns: [('HALLUCINATED', 0.72), ('NOT_HALLUCINATED', 0.28)]

Adaptive Classifier uses ONNX Runtime for high-performance CPU inference.

Automatic Behavior

• On CPU: Automatically uses ONNX (2-4x faster than PyTorch).
• On GPU: Automatically uses PyTorch for maximum performance.

Loading Strategies

When loading a saved model, you can control the ONNX behavior:

• Quantized (Default): Uses INT8 quantization. 4x smaller and significantly faster on x86/ARM.
• Unquantized: Use prefer_quantized=False for maximum accuracy.
• Disable ONNX: Use use_onnx=False to force PyTorch.

Saving Options

• Include ONNX: Default behavior includes both quantized and unquantized versions.
• Exclude ONNX: Use include_onnx=False in .save() to skip ONNX export.

# Save with ONNX export
classifier.save("./model")

# Load automatically uses quantized ONNX on CPU (fastest, 4x smaller)
fast_classifier = AdaptiveClassifier.load("./model")

# Choose unquantized ONNX for maximum accuracy
accurate_classifier = AdaptiveClassifier.load("./model", prefer_quantized=False)

# Force PyTorch (no ONNX)
pytorch_classifier = AdaptiveClassifier.load("./model", use_onnx=False)

# Opt-out of ONNX export when saving
classifier.save("./model", include_onnx=False)

The integration test suite (tests/test_enterprise_classifiers_integration.py) verifies that the 17 enterprise classifiers hosted on Hugging Face Hub maintain expected performance, model loading capabilities, and prediction stability. Use these tests to ensure code changes do not break published models.

Test Coverage

• Model Loading: Verifies models can be loaded from HuggingFace Hub.
• Prediction Functionality: Ensures models make valid predictions.
• k-Parameter Consistency: Regression test ensuring k=1 and k=2 produce consistent results.
• Prediction Stability: Checks if repeated predictions are consistent.
• Performance: Ensures inference completes within 2 seconds.
• Class Coverage: Verifies models recognize all expected classes.
• Health Check: Overall ecosystem health assessment.

# Run all integration tests
pytest tests/test_enterprise_classifiers_integration.py -v

To defend against adversarial inputs (users trying to manipulate the classifier), you can enable strategic_mode via the config dictionary when initializing AdaptiveClassifier. This mode uses game-theoretic principles to model potential manipulation.

# Configuration for strategic mode
config = {
    'enable_strategic_mode': True,
    'cost_function_type': 'linear',
    'cost_coefficients': {
        'sentiment_words': 0.5,    # Cost to change sentiment-bearing words
        'length_change': 0.1,      # Cost to modify text length
        'word_substitution': 0.3   # Cost to substitute words
    },
    'strategic_blend_regular_weight': 0.6,   # Weight for regular predictions
    'strategic_blend_strategic_weight': 0.4  # Weight for strategic predictions
}

classifier = AdaptiveClassifier("bert-base-uncased", config=config)
classifier.add_examples(texts, labels)

text = "This product has amazing quality features!"

# Dual prediction (automatic blend of regular + strategic)
predictions = classifier.predict(text)

# Pure strategic prediction (simulates adversarial manipulation)
strategic_preds = classifier.predict_strategic(text)

# Robust prediction (assumes input may already be manipulated)
robust_preds = classifier.predict_robust(text)

Use AdaptiveClassifier to perform dynamic text classification. You can initialize it with any HuggingFace transformer model, add training examples at runtime to enable continuous learning, and then make predictions.

Workflow:

1. Initialize with a HuggingFace model name.
2. Use .add_examples(texts, labels) to provide training data.
3. Use .predict(text) to get class probabilities.

from adaptive_classifier import AdaptiveClassifier

# Initialize with any HuggingFace model
classifier = AdaptiveClassifier("bert-base-uncased")

# Add training examples
texts = ["The product works great!", "Terrible experience", "Neutral about this purchase"]
labels = ["positive", "negative", "neutral"]
classifier.add_examples(texts, labels)

# Make predictions
predictions = classifier.predict("This is amazing!")
print(predictions)  
# Output: [('positive', 0.85), ('neutral', 0.12), ('negative', 0.03)]