Spaces:
Sleeping
Sleeping
File size: 6,044 Bytes
ea71a9b 8e0e3a9 66185a0 8e0e3a9 66185a0 8e0e3a9 36575bd |
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 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 |
from typing import Dict, Any, List, Optional
from ..knowledge_base.grounding_truth import GroundingTruth
from ..components.response_templates import get_response_templates
import logging
logger = logging.getLogger(__name__)
class ResponseVerifier:
"""Verifies responses using grounding truth while preserving multi-perspective analysis"""
def __init__(self):
self.grounding_truth = GroundingTruth()
self.response_templates = get_response_templates()
self.mode_confidence_thresholds = {
"scientific": 0.9,
"creative": 0.7,
"emotional": 0.6,
"quantum": 0.8,
"philosophical": 0.7
}
def verify_insight(
self,
insight: str,
mode: str,
context: Optional[Dict[str, Any]] = None
) -> Dict[str, Any]:
"""
Verify a single insight from a specific perspective mode
Args:
insight: The insight to verify
mode: The perspective mode that generated it
context: Optional additional context
Returns:
Dict containing verification results and confidence
"""
verification = self.grounding_truth.verify_statement(insight, context)
confidence_threshold = self.mode_confidence_thresholds.get(mode, 0.7)
# Adjust verification based on mode characteristics
if mode == "creative":
# Allow more speculative statements in creative mode
verification["confidence"] *= 1.2
elif mode == "quantum":
# Account for quantum uncertainty
verification["confidence"] = max(
verification["confidence"],
0.5 # Quantum superposition baseline
)
return {
"verified": verification["verified"] or verification["confidence"] >= confidence_threshold,
"confidence": verification["confidence"],
"mode": mode,
"original_insight": insight,
"requires_qualifier": verification["confidence"] < confidence_threshold
}
def process_multi_perspective_response(
self,
insights: List[str],
modes: List[str],
consciousness_state: Optional[Dict[str, Any]] = None
) -> Dict[str, Any]:
"""
Process and verify a multi-perspective response
Args:
insights: List of insights from different perspectives
modes: List of perspective modes that generated the insights
consciousness_state: Optional consciousness state info
Returns:
Processed response with verification metadata
"""
verified_insights = []
uncertain_insights = []
for insight, mode in zip(insights, modes):
result = self.verify_insight(
insight,
mode,
{"consciousness": consciousness_state} if consciousness_state else None
)
if result["verified"]:
verified_insights.append({
"text": result["original_insight"],
"mode": mode,
"confidence": result["confidence"]
})
else:
qualified_insight = self._add_qualifier(
result["original_insight"],
result["confidence"],
mode
)
uncertain_insights.append({
"text": qualified_insight,
"mode": mode,
"confidence": result["confidence"]
})
return {
"verified_insights": verified_insights,
"uncertain_insights": uncertain_insights,
"overall_confidence": self._calculate_overall_confidence(
verified_insights, uncertain_insights
)
}
def _add_qualifier(self, insight: str, confidence: float, mode: str) -> str:
"""Add appropriate qualifier based on confidence and mode"""
base_qualifier = self._get_base_qualifier(confidence)
mode_specific = self._get_mode_qualifier(mode)
if mode_specific:
return f"{base_qualifier} {insight} ({mode_specific})"
return f"{base_qualifier} {insight}"
def _get_base_qualifier(self, confidence: float) -> str:
"""Get base confidence qualifier"""
if confidence >= 0.8:
return "Evidence suggests that"
elif confidence >= 0.6:
return "It appears that"
elif confidence >= 0.4:
uncertain = self.response_templates.get_uncertain_prefix()
return uncertain.rstrip(',') # Remove trailing comma if present
elif confidence >= 0.2:
return "There is a speculation that"
else:
return "There is an unverified hypothesis that"
def _get_mode_qualifier(self, mode: str) -> Optional[str]:
"""Get mode-specific qualifier"""
qualifiers = {
"scientific": "based on available data",
"creative": "from a creative perspective",
"emotional": "from an emotional standpoint",
"quantum": "considering quantum possibilities",
"philosophical": "from a philosophical view"
}
return qualifiers.get(mode)
def _calculate_overall_confidence(
self,
verified: List[Dict[str, Any]],
uncertain: List[Dict[str, Any]]
) -> float:
"""Calculate overall response confidence"""
if not verified and not uncertain:
return 0.0
total_insights = len(verified) + len(uncertain)
confidence_sum = sum(v["confidence"] for v in verified)
confidence_sum += sum(u["confidence"] for u in uncertain)
return confidence_sum / total_insights |