intent-classifier 0.1.0

A flexible few-shot intent classification library for natural language processing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Basic Intent Classification Example
//!
//! This example demonstrates the basic usage of the intent classification library.

use intent_classifier::{IntentClassifier, TrainingExample, TrainingSource, IntentId, IntentFeedback};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    tracing_subscriber::fmt::init();
    
    println!("🚀 Intent Classification Library - Basic Example");
    println!("=================================================");
    
    // Create a new classifier
    println!("\n📚 Creating new classifier...");
    let classifier = IntentClassifier::new().await?;
    
    // Show initial statistics
    let stats = classifier.get_stats().await;
    println!("   Initial training examples: {}", stats.training_examples);
    println!("   Initial vocabulary size: {}", stats.vocabulary_size);
    println!("   Initial intent count: {}", stats.intent_count);
    
    // Test some basic classifications
    println!("\n🔍 Testing basic classifications:");
    
    let test_texts = vec![
        "merge these JSON files together",
        "split this large file into smaller parts",
        "analyze this dataset for patterns",
        "convert PDF to markdown",
        "make an API request to this URL",
        "check if this website is up",
        "extract text from this document",
        "validate this data against schema",
        "analyze this code for issues",
        "hello world",
    ];
    
    for text in test_texts {
        let prediction = classifier.predict_intent(text).await?;
        println!("   📝 '{}' -> {} (confidence: {:.3})", 
                 text, prediction.intent, prediction.confidence.value());
        
        if !prediction.alternative_intents.is_empty() {
            println!("      🔄 Alternatives: {:?}", 
                     prediction.alternative_intents.iter()
                         .map(|(intent, conf)| format!("{}({:.3})", intent, conf.value()))
                         .collect::<Vec<_>>());
        }
    }
    
    // Add custom training data
    println!("\n📖 Adding custom training data...");
    
    let custom_examples = vec![
        TrainingExample {
            text: "calculate the sum of these numbers".to_string(),
            intent: IntentId::from("math_operation"),
            confidence: 1.0,
            source: TrainingSource::Programmatic,
        },
        TrainingExample {
            text: "find the average of this dataset".to_string(),
            intent: IntentId::from("math_operation"),
            confidence: 1.0,
            source: TrainingSource::Programmatic,
        },
        TrainingExample {
            text: "solve this equation".to_string(),
            intent: IntentId::from("math_operation"),
            confidence: 1.0,
            source: TrainingSource::Programmatic,
        },
    ];
    
    for example in custom_examples {
        classifier.add_training_example(example).await?;
    }
    
    // Test the new intent
    println!("\n🧮 Testing new math operations:");
    let math_tests = vec![
        "calculate 2 + 2",
        "what is the average of 1, 2, 3",
        "solve for x in 2x + 3 = 7",
    ];
    
    for text in math_tests {
        let prediction = classifier.predict_intent(text).await?;
        println!("   📝 '{}' -> {} (confidence: {:.3})", 
                 text, prediction.intent, prediction.confidence.value());
    }
    
    // Demonstrate feedback learning
    println!("\n🎯 Demonstrating feedback learning...");
    
    let feedback = IntentFeedback {
        text: "combine these two files".to_string(),
        predicted_intent: IntentId::from("file_write"),
        actual_intent: IntentId::from("data_merge"),
        satisfaction_score: 4.0,
        notes: Some("This should be classified as data merge, not file write".to_string()),
        timestamp: chrono::Utc::now(),
    };
    
    classifier.add_feedback(feedback).await?;
    
    // Test the corrected classification
    let corrected_prediction = classifier.predict_intent("combine these two files").await?;
    println!("   📝 After feedback: 'combine these two files' -> {} (confidence: {:.3})", 
             corrected_prediction.intent, corrected_prediction.confidence.value());
    
    // Show final statistics
    println!("\n📊 Final statistics:");
    let final_stats = classifier.get_stats().await;
    println!("   Training examples: {}", final_stats.training_examples);
    println!("   Vocabulary size: {}", final_stats.vocabulary_size);
    println!("   Intent count: {}", final_stats.intent_count);
    println!("   Feedback examples: {}", final_stats.feedback_examples);
    
    // Export training data
    println!("\n💾 Exporting training data...");
    let exported_data = classifier.export_training_data().await?;
    println!("   Exported {} characters of training data", exported_data.len());
    
    println!("\n✅ Example completed successfully!");
    
    Ok(())
}