wisent 0.1.1__py3-none-any.whl → 0.5.1__py3-none-any.whl

wisent/core/agent/diagnose/tasks/task_relevance.py

@@ -0,0 +1,94 @@
+"""
+Task Relevance Selection for Wisent Guard.
+
+This module provides functionality to select the most relevant tasks from the
+lm-evaluation-harness library based on a user query or issue type.
+
+Uses model-driven decisions instead of hardcoded patterns.
+"""
+
+from typing import List, Dict, Set, Tuple
+from .task_manager import get_available_tasks
+
+
+class TaskRelevanceSelector:
+    """Selects tasks based on model-driven relevance analysis."""
+    
+    def __init__(self, model):
+        self.model = model
+        
+    def find_relevant_tasks(
+        self, 
+        query: str, 
+        max_results: int = 20,
+        min_relevance_score: float = 0.1
+    ) -> List[Tuple[str, float]]:
+        """
+        Find tasks most relevant to the given query using model decisions.
+        
+        Args:
+            query: The search query (e.g., "hallucination detection", "bias", "truthfulness")
+            max_results: Maximum number of tasks to return
+            min_relevance_score: Minimum relevance score threshold (0.0 to 1.0)
+            
+        Returns:
+            List of (task_name, relevance_score) tuples, sorted by relevance
+        """
+        available_tasks = get_available_tasks()
+        
+        # Use model to score task relevance
+        task_scores = []
+        for task_name in available_tasks[:100]:  # Limit for efficiency
+            score = self._get_model_relevance_score(query, task_name)
+            if score >= min_relevance_score:
+                task_scores.append((task_name, score))
+        
+        # Sort by relevance score (descending)
+        task_scores.sort(key=lambda x: x[1], reverse=True)
+        
+        return task_scores[:max_results]
+    
+    def _get_model_relevance_score(self, query: str, task_name: str) -> float:
+        """Get relevance score from the model."""
+        prompt = f"""Rate the relevance of this task for the given query.
+        
+Query: {query}
+Task: {task_name}
+
+Rate relevance from 0.0 to 1.0 (1.0 = highly relevant, 0.0 = not relevant).
+Respond with only the number:"""
+        
+        try:
+            response = self.model.generate(prompt, layer_index=15, max_new_tokens=10, temperature=0.1)
+            score_str = response.strip()
+            
+            # Extract number from response
+            import re
+            match = re.search(r'(\d+\.?\d*)', score_str)
+            if match:
+                score = float(match.group(1))
+                return min(1.0, max(0.0, score))  # Clamp to [0,1]
+            return 0.0
+        except:
+            return 0.0
+
+
+def find_relevant_tasks(
+    query: str, 
+    max_results: int = 20,
+    min_relevance_score: float = 0.1,
+    model=None
+) -> List[Tuple[str, float]]:
+    """Standalone function for task relevance selection."""
+    if model is None:
+        from ....model import Model
+        model = Model("meta-llama/Llama-3.1-8B-Instruct")
+    
+    selector = TaskRelevanceSelector(model)
+    return selector.find_relevant_tasks(query, max_results, min_relevance_score)
+
+
+def get_top_relevant_tasks(query: str, count: int, model=None) -> List[str]:
+    """Get top N relevant tasks for a query."""
+    results = find_relevant_tasks(query, max_results=count, model=model)
+    return [task_name for task_name, _ in results]

wisent/core/agent/diagnose/tasks/task_selector.py

@@ -0,0 +1,151 @@
+"""
+Task Selector for intelligent task selection based on issue types.
+
+This module provides functionality to select the most relevant lm-eval tasks
+for training classifiers for specific issue types using model-driven decisions.
+"""
+
+from typing import List, Dict, Any, Set, Tuple
+from .task_manager import get_available_tasks
+
+
+class TaskSelector:
+    """Model-driven task selector for issue-type-specific training."""
+    
+    def __init__(self, model):
+        self.model = model
+    
+    def find_relevant_tasks_for_issue_type(self, issue_type: str, max_tasks: int = 10) -> List[str]:
+        """
+        Find the most relevant tasks for a specific issue type using model decisions.
+        
+        Args:
+            issue_type: Type of issue to find tasks for
+            max_tasks: Maximum number of tasks to return
+            
+        Returns:
+            List of task names ranked by relevance
+        """
+        available_tasks = get_available_tasks()
+        
+        # Use model to score task relevance for the issue type
+        task_scores = []
+        for task_name in available_tasks[:50]:  # Limit for efficiency
+            score = self._get_model_task_relevance(issue_type, task_name)
+            if score > 0.0:
+                task_scores.append((task_name, score))
+        
+        # Sort by relevance score (descending) and return top tasks
+        task_scores.sort(key=lambda x: x[1], reverse=True)
+        return [task_name for task_name, _ in task_scores[:max_tasks]]
+    
+    def select_best_tasks_for_training(
+        self, 
+        issue_type: str, 
+        min_tasks: int = 1,
+        max_tasks: int = 10,
+        quality_threshold: float = 1.5
+    ) -> List[str]:
+        """
+        Select the best tasks for training a classifier for the given issue type.
+        
+        Args:
+            issue_type: Type of issue to select tasks for
+            min_tasks: Minimum number of tasks to select
+            max_tasks: Maximum number of tasks to select
+            quality_threshold: Minimum quality score for task inclusion
+            
+        Returns:
+            List of selected task names
+        """
+        # Get relevant tasks using model decisions
+        relevant_tasks = self.find_relevant_tasks_for_issue_type(issue_type, max_tasks * 2)
+        
+        # Use model to evaluate task quality
+        selected_tasks = []
+        for task_name in relevant_tasks:
+            quality_score = self._get_model_task_quality(task_name)
+            if quality_score >= quality_threshold or len(selected_tasks) < min_tasks:
+                selected_tasks.append(task_name)
+                if len(selected_tasks) >= max_tasks:
+                    break
+        
+        return selected_tasks[:max_tasks]
+    
+    def _get_model_task_relevance(self, issue_type: str, task_name: str) -> float:
+        """Get task relevance score from the model."""
+        prompt = f"""Rate how relevant this task is for detecting/training on this issue type.
+
+Issue Type: {issue_type}
+Task: {task_name}
+
+Rate relevance from 0.0 to 1.0 (1.0 = highly relevant, 0.0 = not relevant).
+Respond with only the number:"""
+        
+        try:
+            response = self.model.generate(prompt, layer_index=15, max_new_tokens=10, temperature=0.1)
+            score_str = response.strip()
+            
+            import re
+            match = re.search(r'(\d+\.?\d*)', score_str)
+            if match:
+                score = float(match.group(1))
+                return min(1.0, max(0.0, score))
+            return 0.0
+        except:
+            return 0.0
+    
+    def _get_model_task_quality(self, task_name: str) -> float:
+        """Get task quality assessment from the model."""
+        prompt = f"""Rate the quality and reliability of this evaluation task for training AI safety classifiers.
+
+Task: {task_name}
+
+Consider factors like:
+- Data quality and reliability
+- Task design and clarity
+- Usefulness for training safety classifiers
+
+Rate quality from 0.0 to 5.0 (5.0 = excellent quality, 0.0 = poor quality).
+Respond with only the number:"""
+        
+        try:
+            response = self.model.generate(prompt, layer_index=15, max_new_tokens=10, temperature=0.1)
+            score_str = response.strip()
+            
+            import re
+            match = re.search(r'(\d+\.?\d*)', score_str)
+            if match:
+                score = float(match.group(1))
+                return min(5.0, max(0.0, score))
+            return 1.0
+        except:
+            return 1.0
+
+
+def find_relevant_tasks_for_issue_type(issue_type: str, max_tasks: int = 10, model=None) -> List[str]:
+    """Standalone function for finding relevant tasks."""
+    if model is None:
+        from ....model import Model
+        model = Model("meta-llama/Llama-3.1-8B-Instruct")
+    
+    selector = TaskSelector(model)
+    return selector.find_relevant_tasks_for_issue_type(issue_type, max_tasks)
+
+
+def select_best_tasks_for_training(
+    issue_type: str, 
+    min_tasks: int = 1,
+    max_tasks: int = 10,
+    quality_threshold: float = 1.5,
+    model=None
+) -> List[str]:
+    """Standalone function for selecting best training tasks."""
+    if model is None:
+        from ....model import Model
+        model = Model("meta-llama/Llama-3.1-8B-Instruct")
+    
+    selector = TaskSelector(model)
+    return selector.select_best_tasks_for_training(
+        issue_type, min_tasks, max_tasks, quality_threshold
+    ) 

wisent/core/agent/diagnose/test_synthetic_classifier.py

@@ -0,0 +1,71 @@
+import sys
+import time
+import signal
+from pathlib import Path
+
+# Add the project root to the path
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from wisent_guard.core.model import Model
+from wisent_guard.core.agent.diagnose.synthetic_classifier_option import (
+    create_classifiers_for_prompt,
+    apply_classifiers_to_response
+)
+from wisent_guard.core.agent.budget import set_time_budget
+
+class TimeoutError(Exception):
+    """Raised when test exceeds time budget."""
+    pass
+
+def timeout_handler(signum, frame):
+    raise TimeoutError("Test exceeded time budget!")
+
+def main():
+    # Set budget and timeout separately
+    budget_minutes = 1.0  # 1 minute - internal budget for classifier creation
+    timeout_seconds = 120  # 2 minutes - hard timeout for the test process
+    set_time_budget(budget_minutes)
+    
+    print(f"⏱️ Starting synthetic classifier test with {timeout_seconds}s timeout and {budget_minutes*60}s budget...")
+    
+    # Set up timeout signal
+    signal.signal(signal.SIGALRM, timeout_handler)
+    signal.alarm(timeout_seconds)
+    
+    start_time = time.time()
+    
+    try:
+        model = Model(name="meta-llama/Llama-3.1-8B-Instruct")
+        prompt = "What is the capital of France?"
+        
+        # Test the system
+        classifiers, trait_discovery = create_classifiers_for_prompt(model, prompt)
+        
+        # Clear the alarm since we completed successfully
+        signal.alarm(0)
+        
+        elapsed_time = time.time() - start_time
+        print(f"✅ SUCCESS: Created {len(classifiers)} classifiers for {len(trait_discovery.traits_discovered)} traits")
+        print(f"⏱️ Total time: {elapsed_time:.1f}s (timeout: {timeout_seconds}s, budget: {budget_minutes*60}s)")
+        
+        if elapsed_time > timeout_seconds:
+            print(f"⚠️ WARNING: Test completed but exceeded timeout by {elapsed_time - timeout_seconds:.1f}s")
+        else:
+            print(f"🎉 Test completed within timeout with {timeout_seconds - elapsed_time:.1f}s to spare!")
+            
+    except TimeoutError as e:
+        elapsed_time = time.time() - start_time
+        print(f"❌ ERROR: {e}")
+        print(f"❌ Test failed after {elapsed_time:.1f}s (timeout: {timeout_seconds}s, budget: {budget_minutes*60}s)")
+        print("❌ This indicates a performance issue that needs investigation.")
+        sys.exit(1)
+    except Exception as e:
+        signal.alarm(0)  # Clear timeout
+        elapsed_time = time.time() - start_time
+        print(f"❌ ERROR: Test failed with exception: {e}")
+        print(f"❌ Time elapsed: {elapsed_time:.1f}s")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

wisent/core/agent/diagnose.py

@@ -0,0 +1,242 @@
+"""
+Diagnostic module for autonomous agent response analysis.
+
+This module handles:
+- Activation-based response quality assessment using trained classifiers
+- Issue detection through model activations
+- Classifier-based quality scoring
+- Decision making for improvements needed
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+from wisent_guard.core.activations import ActivationAggregationStrategy, Activations
+from wisent_guard.core.classifier.classifier import Classifier
+
+from ..layer import Layer
+from ..model import Model
+
+
+@dataclass
+class AnalysisResult:
+    """Result of self-analysis."""
+
+    has_issues: bool
+    issues_found: List[str]
+    confidence: float
+    suggestions: List[str]
+    quality_score: float
+
+
+class ResponseDiagnostics:
+    """Handles activation-based response analysis and quality assessment for autonomous agents."""
+
+    def __init__(self, model: Model, classifier_configs: List[Dict[str, Any]]):
+        """
+        Initialize the diagnostics system.
+
+        Args:
+            model: The language model to extract activations from
+            classifier_configs: List of classifier configurations with paths and layers
+                Example: [
+                    {"path": "./models/hallucination_classifier.pt", "layer": 15, "issue_type": "hallucination"},
+                    {"path": "./models/quality_classifier.pt", "layer": 20, "issue_type": "quality"}
+                ]
+        """
+        if not classifier_configs:
+            raise ValueError("classifier_configs is required - no fallback mode available")
+
+        self.model = model
+
+        # Load classifiers
+        self.classifiers = []
+        for config in classifier_configs:
+            classifier = Classifier()
+            classifier.load_model(config["path"])
+
+            self.classifiers.append(
+                {
+                    "classifier": classifier,
+                    "layer": Layer(index=config["layer"], type="transformer"),
+                    "issue_type": config.get("issue_type", "unknown"),
+                    "threshold": config.get("threshold", 0.5),
+                }
+            )
+            print(f"✅ Loaded classifier for {config['issue_type']} at layer {config['layer']}")
+
+        if not self.classifiers:
+            raise RuntimeError("Failed to load any classifiers - system cannot operate without them")
+
+    async def analyze_response(self, response: str, prompt: str) -> AnalysisResult:
+        """Analyze the response using trained classifiers and activation patterns."""
+        issues = []
+        confidence_scores = []
+
+        # Classifier-based analysis only
+        classifier_results = self._analyze_with_classifiers(response)
+
+        for result in classifier_results:
+            if result["has_issue"]:
+                issues.append(result["issue_type"])
+                confidence_scores.append(result["confidence"])
+
+        # Quality assessment using classifiers
+        quality_score = self._assess_quality_with_classifiers(response)
+
+        # Overall confidence - requires at least one confidence score
+        if not confidence_scores:
+            raise RuntimeError("No confidence scores available - all classifiers failed")
+        confidence = sum(confidence_scores) / len(confidence_scores)
+
+        # Generate suggestions based on detected issues
+        suggestions = self._generate_suggestions(issues)
+
+        result = AnalysisResult(
+            has_issues=len(issues) > 0,
+            issues_found=issues,
+            confidence=confidence,
+            suggestions=suggestions,
+            quality_score=quality_score,
+        )
+
+        return result
+
+    def _analyze_with_classifiers(self, response: str) -> List[Dict[str, Any]]:
+        """Analyze response using trained classifiers."""
+        results = []
+
+        for classifier_config in self.classifiers:
+            # Extract activations for this classifier's layer
+            activations_tensor = self.model.extract_activations(response, classifier_config["layer"])
+
+            # Create Activations object
+            activations = Activations(
+                tensor=activations_tensor,
+                layer=classifier_config["layer"],
+                aggregation_strategy=ActivationAggregationStrategy.LAST_TOKEN,
+            )
+
+            # Get features for classifier
+            features = activations.extract_features_for_classifier()
+
+            # Get classifier prediction
+            classifier = classifier_config["classifier"]
+            prediction = classifier.predict([features.numpy()])[0]
+            probability = classifier.predict_proba([features.numpy()])[0]
+
+            # Determine if this indicates an issue
+            threshold = classifier_config["threshold"]
+            has_issue = float(probability) > threshold
+            confidence = abs(float(probability) - 0.5) * 2  # Convert to 0-1 confidence
+
+            results.append(
+                {
+                    "issue_type": classifier_config["issue_type"],
+                    "has_issue": has_issue,
+                    "confidence": confidence,
+                    "probability": float(probability),
+                    "prediction": int(prediction),
+                }
+            )
+
+        return results
+
+    def _assess_quality_with_classifiers(self, response: str) -> float:
+        """Assess response quality using classifiers."""
+        quality_scores = []
+
+        for classifier_config in self.classifiers:
+            # Extract activations
+            activations_tensor = self.model.extract_activations(response, classifier_config["layer"])
+
+            # Create Activations object
+            activations = Activations(
+                tensor=activations_tensor,
+                layer=classifier_config["layer"],
+                aggregation_strategy=ActivationAggregationStrategy.LAST_TOKEN,
+            )
+
+            # Get features
+            features = activations.extract_features_for_classifier()
+
+            # Get classifier probability
+            classifier = classifier_config["classifier"]
+            probability = classifier.predict_proba([features.numpy()])[0]
+
+            # Convert probability to quality score
+            # For most classifiers, low probability (closer to 0) = higher quality
+            # This assumes classifiers are trained to detect problems (1 = problematic, 0 = good)
+            quality_score = 1.0 - float(probability)
+            quality_scores.append(quality_score)
+
+        if not quality_scores:
+            raise RuntimeError("No quality scores available - all classifiers failed")
+
+        # Use average quality across all classifiers
+        return sum(quality_scores) / len(quality_scores)
+
+    def _generate_suggestions(self, issues: List[str]) -> List[str]:
+        """Generate improvement suggestions based on detected issues."""
+        suggestions = []
+
+        # Map issue types to suggestions
+        suggestion_map = {
+            "hallucination": "Verify factual accuracy and provide evidence-based responses",
+            "quality": "Improve response relevance, completeness, and clarity",
+            "harmful": "Revise content to be safe and helpful",
+            "bias": "Use more balanced and inclusive language",
+            "gibberish": "Ensure response coherence and proper language structure",
+            "repetitive": "Reduce repetition and vary language patterns",
+            "incoherent": "Improve logical flow and sentence structure",
+        }
+
+        for issue in issues:
+            if issue in suggestion_map:
+                suggestions.append(suggestion_map[issue])
+            else:
+                suggestions.append(f"Address {issue} issue in the response")
+
+        return suggestions
+
+    def decide_if_improvement_needed(
+        self, analysis: AnalysisResult, quality_threshold: float = 0.7, confidence_threshold: float = 0.8
+    ) -> bool:
+        """Decide if the response needs improvement based on classifier results."""
+        # Improvement needed if:
+        # 1. Quality score below threshold
+        # 2. High-confidence issues detected
+        # 3. Multiple issues found
+
+        if analysis.quality_score < quality_threshold:
+            return True
+
+        if analysis.confidence > confidence_threshold and analysis.has_issues:
+            return True
+
+        if len(analysis.issues_found) >= 2:
+            return True
+
+        return False
+
+    def add_classifier(self, classifier_path: str, layer_index: int, issue_type: str, threshold: float = 0.5):
+        """Add a new classifier to the diagnostic system."""
+        classifier = Classifier()
+        classifier.load_model(classifier_path)
+
+        self.classifiers.append(
+            {
+                "classifier": classifier,
+                "layer": Layer(index=layer_index, type="transformer"),
+                "issue_type": issue_type,
+                "threshold": threshold,
+            }
+        )
+        print(f"✅ Added classifier for {issue_type} at layer {layer_index}")
+
+    def get_available_classifiers(self) -> List[Dict[str, Any]]:
+        """Get information about loaded classifiers."""
+        return [
+            {"issue_type": config["issue_type"], "layer": config["layer"].index, "threshold": config["threshold"]}
+            for config in self.classifiers
+        ]