improve learning of new classes

Author: codelion

examples/advanced_usage.py

@@ -24,44 +24,126 @@ def demonstrate_batch_processing():
     logger.info("Demonstrating batch processing...")
 
     # Initialize classifier
-    classifier = AdaptiveClassifier("bert-base-uncased")
+    classifier = AdaptiveClassifier("distilbert/distilbert-base-cased")
 
     # Create a larger dataset
     texts = []
     labels = []
 
     # Simulate customer feedback dataset
     feedback_data = [
+        # Positive feedback
         ("The product is amazing!", "positive"),
+        ("Exceeded all my expectations, truly worth every penny", "positive"),
+        ("Customer service was incredibly helpful and responsive", "positive"),
+        ("Best purchase I've made this year", "positive"),
+        ("The quality is outstanding", "positive"),
+        ("Shipping was super fast and packaging was perfect", "positive"),
+        ("Really impressed with the durability", "positive"),
+        ("Great value for money", "positive"),
+        ("The features are exactly what I needed", "positive"),
+        ("Easy to use and very intuitive", "positive"),
+        ("Fantastic product, will definitely buy again", "positive"),
+        ("Love how lightweight and portable it is", "positive"),
+        ("The installation process was seamless", "positive"),
+        ("Brilliant design and functionality", "positive"),
+        ("Top-notch quality and performance", "positive"),
+
+        # Negative feedback
         ("Worst experience ever", "negative"),
+        ("Product broke after just one week", "negative"),
+        ("Customer support never responded to my emails", "negative"),
+        ("Completely disappointed with the quality", "negative"),
+        ("Not worth the money at all", "negative"),
+        ("Arrived damaged and return process was horrible", "negative"),
+        ("The instructions were impossible to follow", "negative"),
+        ("Poor build quality, feels cheap", "negative"),
+        ("Missing essential features that were advertised", "negative"),
+        ("Terrible battery life", "negative"),
+        ("Keeps malfunctioning randomly", "negative"),
+        ("The worst customer service I've ever experienced", "negative"),
+        ("Save your money and avoid this product", "negative"),
+        ("Doesn't work as advertised", "negative"),
+        ("Had to return it immediately", "negative"),
+
+        # Neutral feedback
         ("It works as expected", "neutral"),
-        # Add more examples...
+        ("Average product, nothing special", "neutral"),
+        ("Does the job, but could be better", "neutral"),
+        ("Reasonable price for what you get", "neutral"),
+        ("Some good features, some bad ones", "neutral"),
+        ("Pretty standard quality", "neutral"),
+        ("Not bad, not great", "neutral"),
+        ("Meets basic requirements", "neutral"),
+        ("Similar to other products in this category", "neutral"),
+        ("Acceptable performance for the price", "neutral"),
+        ("Middle-of-the-road quality", "neutral"),
+        ("Functions adequately", "neutral"),
+        ("Basic functionality works fine", "neutral"),
+        ("Got what I paid for", "neutral"),
+        ("Standard delivery time and service", "neutral"),
+
+        # Technical feedback
+        ("Getting error code 404 when trying to sync", "technical"),
+        ("App crashes after latest update", "technical"),
+        ("Can't connect to WiFi despite correct password", "technical"),
+        ("Battery drains even when device is off", "technical"),
+        ("Screen freezes during startup", "technical"),
+        ("Bluetooth pairing fails consistently", "technical"),
+        ("System shows unrecognized device error", "technical"),
+        ("Software keeps reverting to previous version", "technical"),
+        ("Memory full error after minimal usage", "technical"),
+        ("Device overheats during normal operation", "technical"),
+        ("USB port not recognizing connections", "technical"),
+        ("Network connectivity drops randomly", "technical"),
+        ("Authentication failed error on login", "technical"),
+        ("Sync process stuck at 99%", "technical"),
+        ("Database connection timeout error", "technical")
     ]
 
+    # Number of times to replicate each example
+    num_replications = 10  # This will create 10x more data
+    
     for text, label in feedback_data:
-        texts.extend([text] * 10)  # Replicate each example 10 times for demo
-        labels.extend([label] * 10)
+        # Add multiple copies of each example
+        texts.extend([text] * num_replications)
+        labels.extend([label] * num_replications)
+    
+    logger.info(f"Total examples: {len(texts)}")
+    logger.info(f"Examples per class: {sum(1 for l in labels if l == 'positive')}/{sum(1 for l in labels if l == 'negative')}/"
+                f"{sum(1 for l in labels if l == 'neutral')}/{sum(1 for l in labels if l == 'technical')}")
 
     # Create dataset and dataloader
     dataset = TextDataset(texts, labels)
-    dataloader = DataLoader(dataset, batch_size=32, shuffle=True)
+    batch_size = 8
+    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
+    
+    # Calculate expected number of batches
+    expected_batches = len(dataset) // batch_size + (1 if len(dataset) % batch_size != 0 else 0)
+    logger.info(f"Expected number of batches: {expected_batches}")
 
     # Process in batches
     start_time = time.time()
     for batch_idx, (batch_texts, batch_labels) in enumerate(dataloader):
         classifier.add_examples(batch_texts, batch_labels)
-        if batch_idx % 10 == 0:
-            logger.info(f"Processed batch {batch_idx}")
+        if batch_idx % 5 == 0:  # Log every 5 batches
+            logger.info(f"Processed batch {batch_idx + 1}/{expected_batches}")
+            
+        # Optional: print batch sizes to verify
+        if batch_idx in [0, expected_batches // 2, expected_batches - 1]:  # Print first, middle, and last batch
+            logger.info(f"Batch {batch_idx + 1} size: {len(batch_texts)}")
 
-    logger.info(f"Processing time: {time.time() - start_time:.2f} seconds")
+    processing_time = time.time() - start_time
+    logger.info(f"Processing time: {processing_time:.2f} seconds")
+    logger.info(f"Average time per batch: {processing_time/expected_batches:.2f} seconds")
 
     return classifier
 
 def demonstrate_continuous_learning():
     """Example of continuous learning with performance monitoring"""
     logger.info("Demonstrating continuous learning...")
 
-    classifier = AdaptiveClassifier("bert-base-uncased")
+    classifier = AdaptiveClassifier("distilbert/distilbert-base-cased")
 
     # Initial training
     initial_texts = [
@@ -118,7 +200,7 @@ def evaluate_performance(test_texts: List[str], test_labels: List[str]) -> float
 def demonstrate_persistence():
     # 1. Create and train initial classifier
     print("Phase 1: Creating and training initial classifier")
-    classifier = AdaptiveClassifier("bert-base-uncased")
+    classifier = AdaptiveClassifier("distilbert/distilbert-base-cased")
 
     # Add some initial examples
     initial_texts = [
@@ -170,38 +252,74 @@ def demonstrate_multi_language():
     logger.info("Demonstrating multi-language support...")
 
     # Use a multilingual model
-    classifier = AdaptiveClassifier("bert-base-multilingual-uncased")
+    classifier = AdaptiveClassifier("distilbert/distilbert-base-multilingual-cased")
 
-    # Add examples in different languages
     texts = [
-        # English
+        # English - Positive
         "This is great",
+        "I love this product",
+        "Amazing experience",
+        "Excellent service",
+        "Best purchase ever",
+        "Highly recommended",
+        "Really impressive quality",
+        "Fantastic results",
+        
+        # English - Negative
         "This is terrible",
-        # Spanish
+        "Worst experience ever",
+        "Don't waste your money",
+        "Very disappointed",
+        "Poor quality product",
+        "Absolutely horrible",
+        "Complete waste of time",
+        "Not worth buying",
+        
+        # Spanish - Positive
         "Esto es excelente",
+        "Me encanta este producto",
+        "Una experiencia maravillosa",
+        "Servicio excepcional",
+        "La mejor compra",
+        "Muy recomendable",
+        "Calidad impresionante",
+        "Resultados fantásticos",
+        
+        # Spanish - Negative
         "Esto es terrible",
-        # French
-        "C'est excellent",
-        "C'est terrible"
+        "La peor experiencia",
+        "No malgastes tu dinero",
+        "Muy decepcionado",
+        "Producto de mala calidad",
+        "Absolutamente horrible",
+        "Pérdida total de tiempo",
+        "No vale la pena comprarlo",
     ]
-    
-    labels = ["positive", "negative"] * 3
+
+    labels = ["positive"] * 8 + ["negative"] * 8 \
+        + ["positive"] * 8 + ["negative"] * 8 
 
     classifier.add_examples(texts, labels)
 
     # Test in different languages
     test_texts = [
-        "This is wonderful",  # English
-        "Esto es maravilloso",  # Spanish
-        "C'est merveilleux"  # French
+        # English
+        "This is wonderful",        # Positive
+        "This is terrible",         # Negative
+        
+        # Spanish
+        "Esto es maravilloso",      # Positive
+        "Esto es terrible",         # Negative
     ]
-    
+
+    # Print test results
+    print("\nTesting predictions in multiple languages:")
     for text in test_texts:
         predictions = classifier.predict(text)
-        logger.info(f"\nText: {text}")
-        logger.info("Predictions:")
+        print(f"\nText: {text}")
+        print("Predictions:")
         for label, score in predictions:
-            logger.info(f"{label}: {score:.4f}")
+            print(f"{label}: {score:.4f}")
 
     return classifier
 

examples/basic_usage.py

@@ -1,24 +1,55 @@
+import torch
+import numpy as np
+import random
 from adaptive_classifier import AdaptiveClassifier
 
 def main():
+
     # Initialize classifier
-    classifier = AdaptiveClassifier("bert-base-uncased")
+    classifier = AdaptiveClassifier("distilbert/distilbert-base-cased")
 
-    # Initial training data
+    # Initial training data with atleast 5 examples per class
     texts = [
+        # Positive examples
         "The product works great!",
         "Amazing service, very satisfied",
         "This exceeded my expectations",
+        "Best purchase I've made this year",
+        "Really impressed with the quality",
+        "Fantastic product, will buy again",
+        "Highly recommend this to everyone",
+        
+        # Negative examples
         "Terrible experience, don't buy",
         "Worst product ever",
+        "Complete waste of money",
+        "Poor quality and bad service",
+        "Would not recommend to anyone",
+        "Disappointed with the purchase",
+        "Product broke after first use",
+        
+        # Neutral examples
         "Product arrived on time",
-        "Does what it says"
+        "Does what it says",
+        "Average product, nothing special",
+        "Meets basic requirements",
+        "Fair price for what you get",
+        "Standard quality product",
+        "Works as expected"
     ]
 
     labels = [
+        # Positive labels
+        "positive", "positive", "positive", "positive", 
         "positive", "positive", "positive",
-        "negative", "negative",
-        "neutral", "neutral"
+        
+        # Negative labels
+        "negative", "negative", "negative", "negative",
+        "negative", "negative", "negative",
+        
+        # Neutral labels
+        "neutral", "neutral", "neutral", "neutral",
+        "neutral", "neutral", "neutral"
     ]
 
     # Add examples
@@ -27,18 +58,21 @@ def main():
 
     # Test predictions
     test_texts = [
-        "This is fantastic!",
-        "I hate this product",
-        "It's okay, nothing special"
+        "This is a fantastic product!",
+        "Disappointed with this bad product",
+        "Average product, as expected"
     ]
 
     print("\nTesting predictions:")
-    for text in test_texts:
-        predictions = classifier.predict(text)
-        print(f"\nText: {text}")
-        print("Predictions:")
-        for label, score in predictions:
-            print(f"{label}: {score:.4f}")
+    classifier.model.eval()
+    
+    with torch.no_grad():
+        for text in test_texts:
+            predictions = classifier.predict(text)
+            print(f"\nText: {text}")
+            print("Predictions:")
+            for label, score in predictions:
+                print(f"{label}: {score:.4f}")
 
     # Save the classifier
     print("\nSaving classifier...")
@@ -48,24 +82,33 @@ def main():
     print("\nLoading classifier...")
     loaded_classifier = AdaptiveClassifier.load("./demo_classifier")
 
-    # Add new class
+    # Add new technical class with more examples
     print("\nAdding new technical class...")
     technical_texts = [
         "Error code 404 appeared",
-        "System crashed after update"
+        "System crashed after update",
+        "Cannot connect to database",
+        "Memory allocation failed",
+        "Null pointer exception detected",
+        "API endpoint not responding",
+        "Stack overflow in main thread"
     ]
-    technical_labels = ["technical"] * 2
+    technical_labels = ["technical"] * len(technical_texts)
 
     loaded_classifier.add_examples(technical_texts, technical_labels)
 
     # Test new predictions
     print("\nTesting technical classification:")
-    technical_test = "Getting null pointer exception"
-    predictions = loaded_classifier.predict(technical_test)
-    print(f"\nText: {technical_test}")
-    print("Predictions:")
-    for label, score in predictions:
-        print(f"{label}: {score:.4f}")
+    technical_test = "API giving null pointer exception"
+    
+    loaded_classifier.model.eval()
+    
+    with torch.no_grad():
+        predictions = loaded_classifier.predict(technical_test)
+        print(f"\nText: {technical_test}")
+        print("Predictions:")
+        for label, score in predictions:
+            print(f"{label}: {score:.4f}")
 
 if __name__ == "__main__":
     main()

requirements.txt

@@ -5,4 +5,5 @@ faiss-cpu>=1.7.4  # Use faiss-gpu for GPU support
 numpy>=1.24.0
 tqdm>=4.65.0
 setuptools>=65.0.0
-wheel>=0.40.0
+wheel>=0.40.0
+scikit-learn