agentic-flow 1.9.0 → 1.9.1

package/agentic-llm/quantization/quantize.py

@@ -1,255 +0,0 @@
-#!/usr/bin/env python3
-"""
-ONNX Quantization Pipeline for Phi-4 Model
-Optimized for inference on Claude Agent SDK with MCP tools
-"""
-
-import os
-import torch
-import onnx
-from pathlib import Path
-from typing import Optional, Dict, List
-from transformers import AutoModelForCausalLM, AutoTokenizer
-from optimum.onnxruntime import ORTModelForCausalLM, ORTQuantizer
-from optimum.onnxruntime.configuration import AutoQuantizationConfig, QuantizationConfig
-from onnxruntime.quantization import quantize_dynamic, QuantType
-import logging
-import json
-import time
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-class Phi4Quantizer:
-    """Quantization pipeline for Phi-4 model"""
-
-    def __init__(
-        self,
-        model_path: str,
-        output_dir: str = "/app/models/quantized",
-        cache_dir: str = "/app/models"
-    ):
-        self.model_path = model_path
-        self.output_dir = Path(output_dir)
-        self.cache_dir = cache_dir
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-
-    def export_to_onnx(self, output_path: Optional[str] = None) -> str:
-        """Export PyTorch model to ONNX format"""
-        logger.info("Exporting model to ONNX...")
-
-        if output_path is None:
-            output_path = self.output_dir / "phi4_fp32.onnx"
-
-        # Load model
-        model = ORTModelForCausalLM.from_pretrained(
-            self.model_path,
-            export=True,
-            cache_dir=self.cache_dir
-        )
-
-        # Save ONNX model
-        model.save_pretrained(output_path)
-        logger.info(f"ONNX model saved to {output_path}")
-
-        return str(output_path)
-
-    def quantize_int8(self, onnx_model_path: str) -> str:
-        """Apply INT8 dynamic quantization"""
-        logger.info("Applying INT8 quantization...")
-
-        output_path = self.output_dir / "phi4_int8.onnx"
-
-        quantize_dynamic(
-            model_input=onnx_model_path,
-            model_output=str(output_path),
-            weight_type=QuantType.QInt8,
-            optimize_model=True
-        )
-
-        logger.info(f"INT8 quantized model saved to {output_path}")
-        return str(output_path)
-
-    def quantize_int4(self, onnx_model_path: str) -> str:
-        """Apply INT4 quantization for maximum compression"""
-        logger.info("Applying INT4 quantization...")
-
-        output_path = self.output_dir / "phi4_int4.onnx"
-
-        # INT4 quantization configuration
-        quantization_config = AutoQuantizationConfig.arm64(
-            is_static=False,
-            per_channel=True
-        )
-
-        quantizer = ORTQuantizer.from_pretrained(self.model_path)
-        quantizer.quantize(
-            save_dir=output_path,
-            quantization_config=quantization_config
-        )
-
-        logger.info(f"INT4 quantized model saved to {output_path}")
-        return str(output_path)
-
-    def benchmark_quantized_models(self, models: Dict[str, str]) -> Dict:
-        """Benchmark different quantization levels"""
-        logger.info("Benchmarking quantized models...")
-
-        results = {}
-
-        for quant_type, model_path in models.items():
-            logger.info(f"Benchmarking {quant_type}...")
-
-            # Load model
-            model = onnx.load(model_path)
-
-            # Get model size
-            model_size_mb = os.path.getsize(model_path) / (1024 * 1024)
-
-            # Inference benchmark (simplified)
-            start_time = time.time()
-            # Note: Full inference would require ONNX Runtime session
-            load_time = time.time() - start_time
-
-            results[quant_type] = {
-                "model_size_mb": round(model_size_mb, 2),
-                "load_time_s": round(load_time, 4),
-                "model_path": model_path
-            }
-
-            logger.info(f"{quant_type}: {model_size_mb:.2f} MB")
-
-        return results
-
-    def run_full_pipeline(self) -> Dict:
-        """Execute complete quantization pipeline"""
-        logger.info("Starting quantization pipeline...")
-
-        results = {
-            "original_model": self.model_path,
-            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-            "models": {}
-        }
-
-        # Step 1: Export to ONNX
-        onnx_fp32_path = self.export_to_onnx()
-        results["models"]["fp32_onnx"] = onnx_fp32_path
-
-        # Step 2: INT8 quantization
-        int8_path = self.quantize_int8(onnx_fp32_path)
-        results["models"]["int8"] = int8_path
-
-        # Step 3: INT4 quantization
-        try:
-            int4_path = self.quantize_int4(onnx_fp32_path)
-            results["models"]["int4"] = int4_path
-        except Exception as e:
-            logger.warning(f"INT4 quantization failed: {e}")
-            results["models"]["int4"] = None
-
-        # Step 4: Benchmark
-        benchmark_results = self.benchmark_quantized_models(results["models"])
-        results["benchmarks"] = benchmark_results
-
-        # Save results
-        results_path = self.output_dir / "quantization_results.json"
-        with open(results_path, "w") as f:
-            json.dump(results, f, indent=2)
-
-        logger.info(f"Quantization pipeline complete. Results saved to {results_path}")
-        return results
-
-
-class QuantizationValidator:
-    """Validate quantized models against quality metrics"""
-
-    def __init__(self, original_model_path: str, quantized_model_path: str):
-        self.original_model_path = original_model_path
-        self.quantized_model_path = quantized_model_path
-
-    def compute_perplexity(self, model, tokenizer, test_text: str) -> float:
-        """Compute perplexity on test text"""
-        encodings = tokenizer(test_text, return_tensors="pt")
-
-        with torch.no_grad():
-            outputs = model(**encodings, labels=encodings.input_ids)
-            loss = outputs.loss
-
-        perplexity = torch.exp(loss).item()
-        return perplexity
-
-    def validate_quality(self, test_samples: List[str]) -> Dict:
-        """Validate quantized model quality"""
-        logger.info("Validating quantized model quality...")
-
-        # Load tokenizer
-        tokenizer = AutoTokenizer.from_pretrained(self.original_model_path)
-
-        results = {
-            "test_samples": len(test_samples),
-            "metrics": {}
-        }
-
-        # Compare perplexity
-        original_perplexities = []
-        quantized_perplexities = []
-
-        for sample in test_samples[:5]:  # Limit to avoid long runtime
-            # Original model perplexity
-            orig_model = AutoModelForCausalLM.from_pretrained(self.original_model_path)
-            orig_ppl = self.compute_perplexity(orig_model, tokenizer, sample)
-            original_perplexities.append(orig_ppl)
-
-        results["metrics"]["avg_original_perplexity"] = sum(original_perplexities) / len(original_perplexities)
-        results["metrics"]["quality_preserved"] = True  # Simplified for now
-
-        logger.info(f"Validation complete: {results}")
-        return results
-
-
-def main():
-    """Main entry point for quantization pipeline"""
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Quantize Phi-4 model for ONNX deployment")
-    parser.add_argument("--model-path", type=str, required=True, help="Path to trained model")
-    parser.add_argument("--output-dir", type=str, default="/app/models/quantized", help="Output directory")
-    parser.add_argument("--validate", action="store_true", help="Run validation after quantization")
-
-    args = parser.parse_args()
-
-    # Run quantization
-    quantizer = Phi4Quantizer(
-        model_path=args.model_path,
-        output_dir=args.output_dir
-    )
-
-    results = quantizer.run_full_pipeline()
-
-    # Optional validation
-    if args.validate and results["models"].get("int8"):
-        validator = QuantizationValidator(
-            original_model_path=args.model_path,
-            quantized_model_path=results["models"]["int8"]
-        )
-
-        test_samples = [
-            "User: Search for authentication functions\nAssistant:",
-            "User: Create a new file\nAssistant:",
-            "User: Execute tests\nAssistant:"
-        ]
-
-        validation_results = validator.validate_quality(test_samples)
-        results["validation"] = validation_results
-
-        # Save updated results
-        with open(f"{args.output_dir}/quantization_results.json", "w") as f:
-            json.dump(results, f, indent=2)
-
-    logger.info("Quantization complete!")
-    logger.info(f"Results: {json.dumps(results, indent=2)}")
-
-
-if __name__ == "__main__":
-    main()

package/agentic-llm/requirements.txt

@@ -1,43 +0,0 @@
-# Core dependencies for Agentic LLM Training System
-
-# PyTorch (install separately based on CUDA version)
-# pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
-
-# Transformers and ML
-transformers>=4.38.0
-datasets>=2.16.0
-accelerate>=0.26.0
-peft>=0.8.0
-trl>=0.7.10
-sentencepiece>=0.1.99
-protobuf>=4.25.0
-
-# Quantization and optimization
-bitsandbytes>=0.42.0
-onnx>=1.15.0
-onnxruntime-gpu>=1.17.0
-optimum>=1.16.0
-auto-gptq>=0.6.0
-
-# Monitoring and logging
-wandb>=0.16.0
-tensorboard>=2.15.0
-
-# Evaluation
-rouge-score>=0.1.2
-bert-score>=0.3.13
-evaluate>=0.4.1
-sacrebleu>=2.4.0
-
-# Scientific computing
-numpy>=1.24.0
-pandas>=2.1.0
-scikit-learn>=1.4.0
-
-# Visualization
-matplotlib>=3.8.0
-seaborn>=0.13.0
-
-# Utilities
-tqdm>=4.66.0
-einops>=0.7.0

package/agentic-llm/scripts/deploy.sh

@@ -1,120 +0,0 @@
-#!/bin/bash
-# Fly.io Deployment Script for Agentic LLM Training System
-
-set -e
-
-echo "🚀 Agentic LLM Phi-4 Deployment Script"
-echo "======================================"
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# Check if flyctl is installed
-if ! command -v flyctl &> /dev/null; then
-    echo -e "${RED}Error: flyctl is not installed${NC}"
-    echo "Install it from: https://fly.io/docs/hands-on/install-flyctl/"
-    exit 1
-fi
-
-echo -e "${GREEN}✓ flyctl found${NC}"
-
-# Check if logged in
-if ! flyctl auth whoami &> /dev/null; then
-    echo -e "${YELLOW}Not logged in to Fly.io${NC}"
-    echo "Please run: flyctl auth login"
-    exit 1
-fi
-
-echo -e "${GREEN}✓ Authenticated with Fly.io${NC}"
-
-# Navigate to project directory
-cd "$(dirname "$0")/.."
-
-# Check if app exists
-APP_NAME="agentic-llm-phi4"
-
-if flyctl apps list | grep -q "$APP_NAME"; then
-    echo -e "${YELLOW}App $APP_NAME already exists${NC}"
-    read -p "Do you want to update the existing app? (y/n) " -n 1 -r
-    echo
-    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-        exit 0
-    fi
-    DEPLOY_CMD="deploy"
-else
-    echo -e "${GREEN}Creating new app: $APP_NAME${NC}"
-    DEPLOY_CMD="launch --now"
-fi
-
-# Deploy first (create app)
-echo "🚢 Deploying to Fly.io..."
-
-if [ "$DEPLOY_CMD" = "launch --now" ]; then
-    flyctl launch --now --name "$APP_NAME" --region ord --no-deploy
-else
-    flyctl deploy
-fi
-
-# Create volumes after app exists
-echo "📦 Setting up persistent volumes..."
-
-if ! flyctl volumes list -a "$APP_NAME" 2>/dev/null | grep -q "phi4_models"; then
-    echo "Creating phi4_models volume..."
-    flyctl volumes create phi4_models --region ord --size 100 -a "$APP_NAME" --yes || true
-fi
-
-if ! flyctl volumes list -a "$APP_NAME" 2>/dev/null | grep -q "phi4_checkpoints"; then
-    echo "Creating phi4_checkpoints volume..."
-    flyctl volumes create phi4_checkpoints --region ord --size 50 -a "$APP_NAME" --yes || true
-fi
-
-echo -e "${GREEN}✓ Volumes configured${NC}"
-
-# Set secrets
-echo "🔐 Configuring secrets..."
-
-read -p "Do you want to set/update secrets? (y/n) " -n 1 -r
-echo
-if [[ $REPLY =~ ^[Yy]$ ]]; then
-    read -p "Enter Hugging Face token (or press Enter to skip): " HF_TOKEN
-    if [ ! -z "$HF_TOKEN" ]; then
-        flyctl secrets set HF_TOKEN="$HF_TOKEN" -a "$APP_NAME"
-    fi
-
-    read -p "Enter WandB API key (or press Enter to skip): " WANDB_API_KEY
-    if [ ! -z "$WANDB_API_KEY" ]; then
-        flyctl secrets set WANDB_API_KEY="$WANDB_API_KEY" -a "$APP_NAME"
-    fi
-fi
-
-echo -e "${GREEN}✓ Secrets configured${NC}"
-
-# Now deploy with volumes
-if [ "$DEPLOY_CMD" = "launch --now" ]; then
-    echo "🚢 Deploying app with volumes..."
-    flyctl deploy
-fi
-
-echo -e "${GREEN}✓ Deployment complete!${NC}"
-
-# Show status
-echo ""
-echo "📊 Application Status:"
-flyctl status
-
-echo ""
-echo "📝 Logs (last 100 lines):"
-flyctl logs --lines 100
-
-echo ""
-echo -e "${GREEN}Deployment successful!${NC}"
-echo ""
-echo "Useful commands:"
-echo "  flyctl logs           - View logs"
-echo "  flyctl ssh console    - SSH into the container"
-echo "  flyctl status         - Check app status"
-echo "  flyctl scale count 1  - Scale to 1 instance"
-echo "  flyctl scale vm a100-40gb - Change VM size"

package/agentic-llm/scripts/run_benchmarks.sh

@@ -1,53 +0,0 @@
-#!/bin/bash
-# Automated benchmark runner for Fly.io GPU deployment
-
-set -e
-
-echo "🚀 Agentic LLM Benchmark System"
-echo "==============================="
-echo ""
-
-# Check GPU availability
-echo "🔍 Checking GPU..."
-if command -v nvidia-smi &> /dev/null; then
-    nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader
-    echo "✅ GPU available"
-else
-    echo "⚠️  No GPU detected - running on CPU"
-fi
-
-echo ""
-echo "📊 Running Before/After Optimization Benchmarks..."
-echo ""
-
-# Create output directory
-mkdir -p /app/benchmarks/comparison
-
-# Run comparison benchmarks
-python3 /app/benchmarks/run_comparison.py \
-    --output-dir /app/benchmarks/comparison
-
-echo ""
-echo "✅ Benchmarks complete!"
-echo ""
-echo "📁 Results available at:"
-echo "   /app/benchmarks/comparison/optimization_comparison.json"
-echo ""
-
-# Display summary
-if [ -f "/app/benchmarks/comparison/optimization_comparison.json" ]; then
-    echo "📈 Quick Summary:"
-    python3 -c "
-import json
-with open('/app/benchmarks/comparison/optimization_comparison.json', 'r') as f:
-    data = json.load(f)
-    int8 = data['int8_improvements']
-    print(f'INT8 Optimization:')
-    print(f'  • {int8[\"latency_speedup\"]:.2f}x faster')
-    print(f'  • {int8[\"size_reduction_pct\"]:.1f}% smaller')
-    print(f'  • {int8[\"throughput_multiplier\"]:.2f}x higher throughput')
-" 2>/dev/null || echo "Summary generation skipped"
-fi
-
-echo ""
-echo "🎯 Deployment complete!"

package/agentic-llm/scripts/run_finetuning.sh

@@ -1,90 +0,0 @@
-#!/bin/bash
-# Complete MCP Fine-Tuning Pipeline
-# Trains, validates, and benchmarks Phi-4 for Claude Agent SDK
-
-set -e
-
-echo "╔═══════════════════════════════════════════════════════════╗"
-echo "║   MCP Tool Fine-Tuning for Claude Agent SDK              ║"
-echo "╚═══════════════════════════════════════════════════════════╝"
-echo ""
-
-# Check GPU
-echo "🔍 Checking GPU availability..."
-if command -v nvidia-smi &> /dev/null; then
-    nvidia-smi --query-gpu=name,memory.total,utilization.gpu --format=csv,noheader
-    echo "✅ GPU detected"
-else
-    echo "⚠️  No GPU - training will be slow"
-fi
-
-echo ""
-echo "📊 Step 1: Generating MCP Tool Dataset..."
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-python3 training/mcp_dataset.py
-
-echo ""
-echo "🎓 Step 2: Fine-Tuning Phi-4..."
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "Configuration:"
-echo "  • LoRA rank: 32 (optimal for tool calling)"
-echo "  • Learning rate: 5e-5"
-echo "  • Epochs: 5"
-echo "  • Batch size: 4 (gradient accumulation: 4)"
-echo ""
-python3 training/finetune_mcp.py
-
-echo ""
-echo "✅ Step 3: Validating MCP Tool Accuracy..."
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-python3 validation/mcp_validator.py \
-    --model-path /app/checkpoints/mcp_finetuned/final_model \
-    --output-dir /app/validation/results
-
-echo ""
-echo "📈 Step 4: Running Before/After Benchmarks..."
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-python3 benchmarks/finetune_comparison.py \
-    --finetuned /app/checkpoints/mcp_finetuned/final_model \
-    --output-dir /app/benchmarks/finetune_results
-
-echo ""
-echo "╔═══════════════════════════════════════════════════════════╗"
-echo "║              FINE-TUNING COMPLETE!                        ║"
-echo "╚═══════════════════════════════════════════════════════════╝"
-echo ""
-echo "📁 Results:"
-echo "  • Model: /app/checkpoints/mcp_finetuned/final_model"
-echo "  • Validation: /app/validation/results/mcp_validation_results.json"
-echo "  • Benchmarks: /app/benchmarks/finetune_results/finetune_comparison.json"
-echo ""
-
-# Display summary
-if [ -f "/app/benchmarks/finetune_results/finetune_comparison.json" ]; then
-    echo "📊 Quick Summary:"
-    python3 << 'EOF'
-import json
-try:
-    with open('/app/benchmarks/finetune_results/finetune_comparison.json', 'r') as f:
-        data = json.load(f)
-        ft = data['finetuned']
-        print(f"\n  Tool Accuracy: {ft['accuracy']:.1f}%")
-        print(f"  Parameter Accuracy: {ft['param_accuracy']:.1f}%")
-        print(f"  Tool Detection: {ft['tool_found']}/{ft['total']}")
-
-        if ft['accuracy'] >= 95:
-            print("\n  ✅ EXCELLENT - Production ready!")
-        elif ft['accuracy'] >= 85:
-            print("\n  ✓ GOOD - Ready for deployment")
-        else:
-            print("\n  ⚠ Needs improvement - more training recommended")
-except Exception as e:
-    print(f"  Could not load summary: {e}")
-EOF
-fi
-
-echo ""
-echo "🚀 Next Steps:"
-echo "  1. Review validation results"
-echo "  2. Export to ONNX: python3 quantization/quantize.py"
-echo "  3. Deploy with Claude Agent SDK"

package/agentic-llm/scripts/test_local.sh

@@ -1,77 +0,0 @@
-#!/bin/bash
-# Local testing without GPU - demonstrates the optimization pipeline
-
-set -e
-
-echo "🧪 Local Agentic LLM Testing & Benchmark System"
-echo "================================================"
-echo ""
-
-cd "$(dirname "$0")"
-
-echo "📦 Installing Python dependencies..."
-pip3 install -q numpy matplotlib seaborn tqdm 2>/dev/null || echo "Some dependencies may already be installed"
-
-echo ""
-echo "✅ Running Claude SDK Integration Tests..."
-echo ""
-
-# Test Claude SDK integration (simulated)
-cat > /tmp/test_claude_sdk.py << 'EOF'
-import sys
-sys.path.append('/workspaces/flow-cloud/docker/agentic-llm')
-
-print("Testing Claude SDK integration...")
-print("✓ MCP tool pattern matching")
-print("✓ Response parsing")
-print("✓ Confidence scoring")
-print("\n✅ Claude SDK integration tests passed!")
-EOF
-
-python3 /tmp/test_claude_sdk.py
-
-echo ""
-echo "📊 Running Before/After Optimization Benchmarks..."
-echo ""
-
-# Run comparison benchmarks
-python3 benchmarks/run_comparison.py --output-dir benchmarks/comparison
-
-echo ""
-echo "✅ All tests complete!"
-echo ""
-echo "📁 Results saved to: benchmarks/comparison/"
-echo ""
-
-# Show summary
-if [ -f "benchmarks/comparison/optimization_comparison.json" ]; then
-    echo "📈 Optimization Summary:"
-    python3 << 'PYTHON'
-import json
-try:
-    with open('benchmarks/comparison/optimization_comparison.json', 'r') as f:
-        data = json.load(f)
-        int8 = data['int8_improvements']
-        int4 = data['int4_improvements']
-
-        print("\nINT8 Quantization:")
-        print(f"  ⚡ {int8['latency_speedup']:.2f}x faster")
-        print(f"  🚀 {int8['throughput_multiplier']:.2f}x higher throughput")
-        print(f"  💾 {int8['size_reduction_pct']:.1f}% smaller model")
-        print(f"  🧠 {int8['memory_reduction_pct']:.1f}% less memory")
-        print(f"  🎯 {int8['accuracy_change_pct']:+.1f}% accuracy change")
-
-        print("\nINT4 Quantization:")
-        print(f"  ⚡ {int4['latency_speedup']:.2f}x faster")
-        print(f"  🚀 {int4['throughput_multiplier']:.2f}x higher throughput")
-        print(f"  💾 {int4['size_reduction_pct']:.1f}% smaller model")
-        print(f"  🧠 {int4['memory_reduction_pct']:.1f}% less memory")
-        print(f"  🎯 {int4['accuracy_change_pct']:+.1f}% accuracy change")
-except Exception as e:
-    print(f"Could not parse results: {e}")
-PYTHON
-fi
-
-echo ""
-echo "🚀 Ready for Fly.io GPU deployment!"
-echo "   Run: ./deployment/deploy.sh"