fix:LoRA Model Training Configuration and Data Balance

Signed-off-by: OneZero-Y <[email protected]>

Author: OneZero-Y

src/training/training_lora/OWNER

@@ -0,0 +1,2 @@
+# lora training owners
+@OneZero-Y

src/training/training_lora/classifier_model_fine_tuning_lora/ft_linear_lora.py

@@ -444,7 +444,7 @@ def main(
     lora_dropout: float = 0.1,
     num_epochs: int = 3,
     batch_size: int = 8,
-    learning_rate: float = 1e-4,
+    learning_rate: float = 3e-5,  # Reduced from 1e-4 to prevent gradient explosion
     max_samples: int = 1000,
     output_dir: str = None,
     enable_feature_alignment: bool = False,
@@ -493,13 +493,12 @@ def main(
 
     logger.info(f"Model will be saved to: {output_dir}")
 
-    # Training arguments
+    # Training arguments optimized for LoRA sequence classification based on PEFT best practices
     training_args = TrainingArguments(
         output_dir=output_dir,
         num_train_epochs=num_epochs,
         per_device_train_batch_size=batch_size,
         per_device_eval_batch_size=batch_size,
-        warmup_steps=100,
         weight_decay=0.01,
         logging_dir=f"{output_dir}/logs",
         logging_steps=10,
@@ -509,6 +508,13 @@ def main(
         metric_for_best_model="eval_f1",
         greater_is_better=True,
         learning_rate=learning_rate,
+        # PEFT optimization: Enhanced stability measures
+        max_grad_norm=1.0,  # Gradient clipping to prevent explosion
+        lr_scheduler_type="cosine",  # More stable learning rate schedule for LoRA
+        warmup_ratio=0.06,  # PEFT recommended warmup ratio for sequence classification
+        # Additional stability measures for intent classification
+        dataloader_drop_last=False,
+        eval_accumulation_steps=1,
     )
 
     # Create trainer
@@ -728,7 +734,7 @@ def demo_inference(model_path: str, model_name: str = "modernbert-base"):
     parser.add_argument("--alignment-weight", type=float, default=0.1)
     parser.add_argument("--epochs", type=int, default=3)
     parser.add_argument("--batch-size", type=int, default=8)
-    parser.add_argument("--learning-rate", type=float, default=1e-4)
+    parser.add_argument("--learning-rate", type=float, default=3e-5)
     parser.add_argument(
         "--max-samples",
         type=int,

src/training/training_lora/classifier_model_fine_tuning_lora/ft_linear_lora_verifier.go

@@ -8,6 +8,7 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"strings"
 
 	candle "github.com/vllm-project/semantic-router/candle-binding"
 )
@@ -209,34 +210,192 @@ func main() {
 		log.Fatalf("Failed to initialize LoRA classifier: %v", err)
 	}
 
-	// Test samples for intent classification (matching Python demo_inference)
-	testSamples := []string{
-		"What is the best strategy for corporate mergers and acquisitions?",
-		"How do antitrust laws affect business competition?",
-		"What are the psychological factors that influence consumer behavior?",
-		"Explain the legal requirements for contract formation",
-		"What is the difference between civil and criminal law?",
-		"How does cognitive bias affect decision making?",
+	// Test samples with expected intent categories for validation
+	testSamples := []struct {
+		text        string
+		description string
+		expected    string
+	}{
+		{
+			"What is the best strategy for corporate mergers and acquisitions?",
+			"Business strategy question",
+			"business",
+		},
+		{
+			"How do antitrust laws affect business competition?",
+			"Business law question",
+			"business",
+		},
+		{
+			"What are the psychological factors that influence consumer behavior?",
+			"Psychology and behavior question",
+			"psychology",
+		},
+		{
+			"Explain the legal requirements for contract formation",
+			"Legal concepts question",
+			"jurisprudence",
+		},
+		{
+			"What is the difference between civil and criminal law?",
+			"Legal system question",
+			"jurisprudence",
+		},
+		{
+			"How does cognitive bias affect decision making?",
+			"Psychology and cognition question",
+			"psychology",
+		},
+		{
+			"What is the derivative of e^x?",
+			"Mathematical calculus question",
+			"mathematics",
+		},
+		{
+			"Explain the concept of supply and demand in economics.",
+			"Economic principles question",
+			"economics",
+		},
+		{
+			"How does DNA replication work in eukaryotic cells?",
+			"Biology and genetics question",
+			"biology",
+		},
+		{
+			"What is the difference between a civil law and common law system?",
+			"Legal systems comparison",
+			"jurisprudence",
+		},
+		{
+			"Explain how transistors work in computer processors.",
+			"Computer engineering question",
+			"computer_science",
+		},
+		{
+			"Why do stars twinkle?",
+			"Astronomical physics question",
+			"physics",
+		},
+		{
+			"How do I create a balanced portfolio for retirement?",
+			"Financial planning question",
+			"economics",
+		},
+		{
+			"What causes mental illnesses?",
+			"Mental health and psychology question",
+			"psychology",
+		},
+		{
+			"How do computer algorithms work?",
+			"Computer science fundamentals",
+			"computer_science",
+		},
+		{
+			"Explain the historical significance of the Roman Empire.",
+			"Historical analysis question",
+			"history",
+		},
+		{
+			"What is the derivative of f(x) = x^3 + 2x^2 - 5x + 7?",
+			"Calculus problem",
+			"mathematics",
+		},
+		{
+			"Describe the process of photosynthesis in plants.",
+			"Biological processes question",
+			"biology",
+		},
+		{
+			"What are the principles of macroeconomic policy?",
+			"Economic policy question",
+			"economics",
+		},
+		{
+			"How does machine learning classification work?",
+			"Machine learning concepts",
+			"computer_science",
+		},
+		{
+			"What is the capital of France?",
+			"General knowledge question",
+			"other",
+		},
 	}
 
 	fmt.Println("\nTesting LoRA Intent Classification:")
 	fmt.Println("===================================")
 
-	for i, sample := range testSamples {
-		fmt.Printf("\nTest %d: %s\n", i+1, sample)
+	// Statistics tracking
+	var (
+		totalTests     = len(testSamples)
+		correctTests   = 0
+		highConfidence = 0
+		lowConfidence  = 0
+	)
+
+	for i, test := range testSamples {
+		fmt.Printf("\nTest %d: %s\n", i+1, test.description)
+		fmt.Printf("   Text: \"%s\"\n", test.text)
 
-		result, err := classifyIntentText(sample, config)
+		result, err := classifyIntentText(test.text, config)
 		if err != nil {
-			fmt.Printf("Error: %v\n", err)
+			fmt.Printf("   Classification failed: %v\n", err)
 			continue
 		}
 
+		// Get the predicted label name
+		labelName := "unknown"
 		if label, exists := categoryLabels[result.Class]; exists {
-			fmt.Printf("Classification: %s (Class ID: %d, Confidence: %.4f)\n", label, result.Class, result.Confidence)
+			labelName = label
+		}
+
+		// Print the result
+		fmt.Printf("   Classified as: %s (Class ID: %d, Confidence: %.4f)\n",
+			labelName, result.Class, result.Confidence)
+
+		// Check correctness
+		isCorrect := labelName == test.expected
+		if isCorrect {
+			fmt.Printf("   ✓ CORRECT")
+			correctTests++
 		} else {
-			fmt.Printf("Unknown category index: %d (Confidence: %.4f)\n", result.Class, result.Confidence)
+			fmt.Printf("   ✗ INCORRECT (Expected: %s)", test.expected)
 		}
+
+		// Add confidence assessment
+		if result.Confidence > 0.7 {
+			fmt.Printf(" - HIGH CONFIDENCE\n")
+			highConfidence++
+		} else if result.Confidence > 0.5 {
+			fmt.Printf(" - MEDIUM CONFIDENCE\n")
+		} else {
+			fmt.Printf(" - LOW CONFIDENCE\n")
+			lowConfidence++
+		}
+	}
+
+	// Print comprehensive summary
+	fmt.Println("\n" + strings.Repeat("=", 50))
+	fmt.Println("INTENT CLASSIFICATION TEST SUMMARY")
+	fmt.Println(strings.Repeat("=", 50))
+	fmt.Printf("Total Tests: %d\n", totalTests)
+	fmt.Printf("Correct Predictions: %d/%d (%.1f%%)\n", correctTests, totalTests, float64(correctTests)/float64(totalTests)*100)
+	fmt.Printf("High Confidence (>0.7): %d/%d (%.1f%%)\n", highConfidence, totalTests, float64(highConfidence)/float64(totalTests)*100)
+	fmt.Printf("Low Confidence (<0.5): %d/%d (%.1f%%)\n", lowConfidence, totalTests, float64(lowConfidence)/float64(totalTests)*100)
+
+	// Overall assessment
+	accuracy := float64(correctTests) / float64(totalTests) * 100
+	fmt.Printf("\nOVERALL ASSESSMENT: ")
+	if accuracy >= 85.0 {
+		fmt.Printf("EXCELLENT (%.1f%% accuracy)\n", accuracy)
+	} else if accuracy >= 70.0 {
+		fmt.Printf("GOOD (%.1f%% accuracy)\n", accuracy)
+	} else if accuracy >= 50.0 {
+		fmt.Printf("FAIR (%.1f%% accuracy) - Consider retraining\n", accuracy)
+	} else {
+		fmt.Printf("POOR (%.1f%% accuracy) - Requires retraining\n", accuracy)
 	}
 
-	fmt.Println("\nLoRA Intent Classification test completed!")
+	fmt.Println("\nLoRA Intent Classification verification completed!")
 }

src/training/training_lora/classifier_model_fine_tuning_lora/train_cpu_optimized.sh

@@ -17,7 +17,7 @@ LORA_RANK=8                  # Optimal rank for stability and performance
 LORA_ALPHA=16                # Standard alpha (2x rank) for best results
 MAX_SAMPLES=7000             # Increased samples for better coverage of 14 categories
 BATCH_SIZE=2                 # Small batch size for CPU
-LEARNING_RATE=1e-4           # Lower learning rate for more stable training
+LEARNING_RATE=3e-5           # Optimized learning rate based on  PEFT best practices
 
 # CPU-friendly model set (smaller models only)
 CPU_MODELS=(
@@ -131,12 +131,14 @@ train_cpu_model() {
 
     # CPU-optimized training command
     local cmd="python ft_linear_lora.py \
+        --mode train \
         --model $model_name \
         --epochs $EPOCHS \
-        --max-samples $MAX_SAMPLES \
         --lora-rank $LORA_RANK \
+        --lora-alpha $LORA_ALPHA \
+        --max-samples $MAX_SAMPLES \
         --batch-size $BATCH_SIZE \
-        --output-dir lora_intent_classifier_${model_name}_r${LORA_RANK}_model"
+        --learning-rate $LEARNING_RATE"
 
     echo "📝 Command: $cmd"
     echo "📋 Log file: $log_file"

src/training/training_lora/pii_model_fine_tuning_lora/pii_bert_finetuning_lora.py

@@ -423,7 +423,7 @@ def validate_bio_labels(texts, token_labels):
 
     # Show entity statistics
     if entity_stats:
-        logger.info(f"📈 Entity Statistics:")
+        logger.info(f"Entity Statistics:")
         for entity_type, stats in sorted(
             entity_stats.items(), key=lambda x: x[1]["count"], reverse=True
         )[:5]:
@@ -432,9 +432,9 @@ def validate_bio_labels(texts, token_labels):
             )
 
     if bio_violations > 0:
-        logger.warning(f"⚠️  Found {bio_violations} BIO labeling violations!")
+        logger.warning(f"Found {bio_violations} BIO labeling violations!")
     else:
-        logger.info("✅ All BIO labels are consistent!")
+        logger.info("All BIO labels are consistent!")
 
     return {
         "total_samples": total_samples,
@@ -447,16 +447,16 @@ def validate_bio_labels(texts, token_labels):
 
 def analyze_data_quality(texts, token_labels, sample_size=5):
     """Analyze and display data quality with sample examples."""
-    logger.info(f"🔍 Data Quality Analysis:")
+    logger.info(f"Data Quality Analysis:")
 
     # Show sample examples with their labels
-    logger.info(f"📝 Sample Examples (showing first {sample_size}):")
+    logger.info(f"Sample Examples (showing first {sample_size}):")
     for i in range(min(sample_size, len(texts))):
         tokens = texts[i]
         labels = token_labels[i]
 
-        logger.info(f"  Sample {i+1}:")
-        logger.info(f"    Text: {' '.join(tokens)}")
+        logger.info(f"Sample {i+1}:")
+        logger.info(f"Text: {' '.join(tokens)}")
 
         # Show only non-O labels for clarity
         entities = []
@@ -633,7 +633,7 @@ def main(
     lora_dropout: float = 0.1,
     num_epochs: int = 3,
     batch_size: int = 8,
-    learning_rate: float = 1e-4,
+    learning_rate: float = 3e-5,  # Optimized for LoRA based on PEFT best practices
     max_samples: int = 1000,
 ):
     """Main training function for LoRA PII detection."""
@@ -682,13 +682,17 @@ def main(
     os.makedirs(output_dir, exist_ok=True)
 
     # Training arguments
+    # Training arguments optimized for LoRA token classification based on PEFT best practices
     training_args = TrainingArguments(
         output_dir=output_dir,
         num_train_epochs=num_epochs,
         per_device_train_batch_size=batch_size,
         per_device_eval_batch_size=batch_size,
         learning_rate=learning_rate,
-        warmup_steps=50,
+        # PEFT optimization: Enhanced stability measures
+        max_grad_norm=1.0,  # Gradient clipping to prevent explosion
+        lr_scheduler_type="cosine",  # More stable learning rate schedule for LoRA
+        warmup_ratio=0.06,  # PEFT recommended warmup ratio for token classification
         weight_decay=0.01,
         logging_dir=f"{output_dir}/logs",
         logging_steps=10,
@@ -697,6 +701,9 @@ def main(
         load_best_model_at_end=True,
         metric_for_best_model="f1",
         save_total_limit=2,
+        # Additional stability measures
+        dataloader_drop_last=False,
+        eval_accumulation_steps=1,
         report_to=[],
         fp16=torch.cuda.is_available(),
     )
@@ -968,7 +975,7 @@ def demo_inference(
             lora_dropout=args.lora_dropout,
             num_epochs=args.epochs,
             batch_size=args.batch_size,
-            learning_rate=args.learning_rate,
+            learning_rate=3e-5,  # Default optimized learning rate for LoRA token classification
             max_samples=args.max_samples,
         )
     elif args.mode == "test":