Upload check.txt.txt

QA_result/check.txt.txt

@@ -0,0 +1,620 @@
+"""
+Emotion Detection Service Module
+
+Provides async emotion detection from audio with:
+- Concurrent request handling via semaphores
+- Audio chunking for multi-emotion detection
+- Temporary file management
+- Thread-safe model inference
+"""
+
+import asyncio
+import os
+import uuid
+import threading
+import numpy as np
+import soundfile as sf
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Any
+from datetime import datetime
+from collections import defaultdict
+
+from .config import EmotionConfig, get_emotion_config
+from .history import EmotionHistory, EmotionTurn, build_emotion_prompt_context
+
+
+def _ensure_mono_1d(audio: np.ndarray) -> np.ndarray:
+    """
+    Ensure audio is a 1D mono array.
+
+    Handles various audio formats:
+    - Already 1D: return as-is
+    - (samples, channels): transpose and average channels
+    - (channels, samples): average channels
+    - (1, samples) or (samples, 1): squeeze to 1D
+
+    Args:
+        audio: Audio data as numpy array (1D or 2D)
+
+    Returns:
+        1D mono audio array
+    """
+    if audio.ndim == 1:
+        return audio
+
+    if audio.ndim != 2:
+        # For higher dimensional arrays, try to flatten
+        print(f"[EMOTION] Warning: unexpected audio shape {audio.shape}, attempting to flatten")
+        return audio.flatten()
+
+    # 2D array - determine format and convert to mono
+    rows, cols = audio.shape
+
+    # Check if one dimension is small (likely channels: 1 or 2)
+    if rows <= 2 and cols > 2:
+        # Shape is (channels, samples) - average across axis 0
+        if rows == 1:
+            return audio.squeeze(axis=0)
+        else:
+            return np.mean(audio, axis=0)
+
+    elif cols <= 2 and rows > 2:
+        # Shape is (samples, channels) - average across axis 1
+        if cols == 1:
+            return audio.squeeze(axis=1)
+        else:
+            return np.mean(audio, axis=1)
+
+    else:
+        # Both dimensions are large or both are small
+        # Heuristic: if rows > cols, assume (samples, channels)
+        if rows > cols:
+            if cols == 1:
+                return audio.squeeze(axis=1)
+            return np.mean(audio, axis=1)
+        else:
+            if rows == 1:
+                return audio.squeeze(axis=0)
+            return np.mean(audio, axis=0)
+
+
+class EmotionDetectionService:
+    """
+    Async-safe emotion detection service.
+
+    Handles:
+    - Audio preprocessing and chunking
+    - Concurrent request management via semaphores
+    - Temporary file lifecycle
+    - Model inference with thread safety
+    """
+
+    def __init__(self, config: Optional[EmotionConfig] = None):
+        """
+        Initialize the emotion detection service.
+
+        Args:
+            config: Optional EmotionConfig. If not provided, loads from .env
+        """
+        self.config = config or get_emotion_config()
+        self._model = None
+        self._model_lock = threading.Lock()
+        self._semaphore: Optional[asyncio.Semaphore] = None
+        self._history = EmotionHistory()
+        self._initialized = False
+
+        # Track active requests for debugging
+        self._active_requests: Dict[str, datetime] = {}
+        self._request_lock = threading.Lock()
+
+        if self.config.enabled:
+            self._initialize()
+
+    def _initialize(self):
+        """Initialize the service (load model, create directories)."""
+        if self._initialized:
+            return
+
+        try:
+            # Create temp directory
+            Path(self.config.temp_audio_dir).mkdir(parents=True, exist_ok=True)
+            print(f"[EMOTION] Temp audio directory: {self.config.temp_audio_dir}")
+
+            # Create semaphore for concurrent task limiting
+            self._semaphore = asyncio.Semaphore(self.config.max_concurrent_tasks)
+            print(f"[EMOTION] Max concurrent tasks: {self.config.max_concurrent_tasks}")
+
+            # Lazy load model on first use
+            self._initialized = True
+            print(f"[EMOTION] Service initialized successfully")
+
+        except Exception as e:
+            print(f"[EMOTION] Failed to initialize service: {e}")
+            self.config.enabled = False
+
+    def _ensure_model(self):
+        """Ensure model is loaded (lazy loading with thread safety)."""
+        if self._model is not None:
+            return
+
+        with self._model_lock:
+            if self._model is not None:
+                return
+
+            try:
+                import onnxruntime as ort
+
+                # Check available providers
+                available = ort.get_available_providers()
+                providers = []
+                if "CUDAExecutionProvider" in available:
+                    providers.append("CUDAExecutionProvider")
+                    print(f"[EMOTION] CUDA available, using GPU acceleration")
+                providers.append("CPUExecutionProvider")
+
+                # Load model
+                self._model = ort.InferenceSession(
+                    self.config.model_path,
+                    providers=providers
+                )
+
+                # Log model info
+                actual_provider = self._model.get_providers()[0]
+                print(f"[EMOTION] Model loaded from: {self.config.model_path}")
+                print(f"[EMOTION] Running on: {actual_provider}")
+
+            except Exception as e:
+                print(f"[EMOTION] Failed to load model: {e}")
+                self.config.enabled = False
+                raise
+
+    def _generate_request_id(self) -> str:
+        """Generate unique request ID for tracking."""
+        return f"emo_{uuid.uuid4().hex[:12]}_{int(datetime.now().timestamp() * 1000)}"
+
+    def _get_temp_audio_path(self, request_id: str, chunk_idx: int = 0) -> str:
+        """
+        Generate temporary audio file path.
+
+        Args:
+            request_id: Unique request identifier
+            chunk_idx: Index of audio chunk (for multi-emotion)
+
+        Returns:
+            Full path to temporary audio file
+        """
+        filename = f"{request_id}_chunk{chunk_idx}{self.config.audio_extension}"
+        return os.path.join(self.config.temp_audio_dir, filename)
+
+    def _split_audio_into_chunks(
+        self,
+        audio: np.ndarray,
+        sample_rate: int,
+        chunk_duration: int
+    ) -> List[np.ndarray]:
+        """
+        Split audio into fixed-duration chunks.
+
+        Args:
+            audio: Audio data as numpy array (1D or 2D)
+            sample_rate: Sample rate of audio
+            chunk_duration: Duration of each chunk in seconds
+
+        Returns:
+            List of audio chunks as numpy arrays (1D mono)
+        """
+        # Ensure audio is 1D mono before processing
+        audio = _ensure_mono_1d(audio)
+
+        chunk_samples = chunk_duration * sample_rate
+        total_samples = len(audio)
+
+        if total_samples <= chunk_samples:
+            # Single chunk, pad if needed
+            if total_samples < chunk_samples:
+                audio = np.pad(audio, (0, chunk_samples - total_samples), mode='constant')
+            return [audio]
+
+        # Split into multiple chunks
+        chunks = []
+        for start in range(0, total_samples, chunk_samples):
+            end = start + chunk_samples
+            chunk = audio[start:end]
+
+            # Pad last chunk if needed
+            if len(chunk) < chunk_samples:
+                chunk = np.pad(chunk, (0, chunk_samples - len(chunk)), mode='constant')
+
+            chunks.append(chunk)
+
+        return chunks
+
+    async def _save_audio_chunk(
+        self,
+        audio: np.ndarray,
+        sample_rate: int,
+        path: str
+    ) -> bool:
+        """
+        Save audio chunk to file asynchronously.
+
+        Args:
+            audio: Audio data
+            sample_rate: Sample rate
+            path: Output file path
+
+        Returns:
+            True if successful
+        """
+        try:
+            # Run file I/O in thread pool
+            await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: sf.write(path, audio.astype(np.float32), sample_rate)
+            )
+            return True
+        except Exception as e:
+            print(f"[EMOTION] Failed to save audio chunk: {e}")
+            return False
+
+    def _cleanup_temp_file(self, path: str):
+        """Remove temporary audio file."""
+        if self.config.cleanup_temp_files:
+            try:
+                if os.path.exists(path):
+                    os.remove(path)
+            except Exception as e:
+                print(f"[EMOTION] Failed to cleanup temp file {path}: {e}")
+
+    def _run_inference(self, audio_path: str) -> Dict[str, float]:
+        """
+        Run emotion inference on audio file.
+
+        Args:
+            audio_path: Path to audio file
+
+        Returns:
+            Dict mapping emotion class to confidence score
+        """
+        self._ensure_model()
+
+        try:
+            import librosa
+            from audio_emotion_detection.preprocessing import MelSTFT
+
+            # Get model input/output info
+            input_name = self._model.get_inputs()[0].name
+            output_name = self._model.get_outputs()[0].name
+
+            # Preprocess audio
+            mel = MelSTFT(n_mels=128, sr=32000, win_length=800, hopsize=320)
+            waveform, _ = librosa.core.load(audio_path, sr=32000, mono=True)
+            waveform = np.stack([waveform])
+            spec = mel(waveform)
+
+            # Ensure correct temporal dimension (400 frames for ~4s audio)
+            if spec.shape[-1] > 400:
+                spec = spec[:, :, :400]
+            else:
+                spec = np.pad(spec, ((0, 0), (0, 0), (0, 400 - spec.shape[-1])), mode='constant')
+
+            spec = np.expand_dims(spec, axis=0).astype(np.float32)
+
+            # Run inference
+            output = self._model.run([output_name], {input_name: spec})
+
+            # Softmax
+            logits = output[0][0]
+            exp_logits = np.exp(logits - np.max(logits))
+            probs = exp_logits / np.sum(exp_logits)
+
+            # Map to emotion classes
+            results = {}
+            for i, class_name in enumerate(self.config.class_labels):
+                results[class_name] = float(probs[i])
+
+            return results
+
+        except Exception as e:
+            print(f"[EMOTION] Inference failed: {e}")
+            import traceback
+            traceback.print_exc()
+            return {}
+
+    async def detect_emotion(
+        self,
+        audio: np.ndarray,
+        sample_rate: int,
+        request_id: Optional[str] = None
+    ) -> Dict[str, float]:
+        """
+        Detect emotion from single audio segment.
+
+        Args:
+            audio: Audio data as numpy array (1D or 2D)
+            sample_rate: Sample rate of audio
+            request_id: Optional request ID for tracking
+
+        Returns:
+            Dict mapping emotion class to confidence score
+        """
+        if not self.config.enabled:
+            return {}
+
+        request_id = request_id or self._generate_request_id()
+
+        # Ensure audio is 1D mono before processing
+        audio = _ensure_mono_1d(audio)
+
+        # Track request
+        with self._request_lock:
+            self._active_requests[request_id] = datetime.now()
+
+        try:
+            # Acquire semaphore for concurrency control
+            async with self._semaphore:
+                # Resample if needed
+                if sample_rate != self.config.sample_rate:
+                    try:
+                        import librosa
+                        audio = librosa.resample(
+                            audio.astype(np.float32),
+                            orig_sr=sample_rate,
+                            target_sr=self.config.sample_rate
+                        )
+                        sample_rate = self.config.sample_rate
+                    except Exception as e:
+                        print(f"[EMOTION] Resampling failed: {e}")
+
+                # Ensure correct duration
+                target_samples = self.config.audio_duration * sample_rate
+                if len(audio) > target_samples:
+                    audio = audio[:target_samples]
+                elif len(audio) < target_samples:
+                    audio = np.pad(audio, (0, target_samples - len(audio)), mode='constant')
+
+                # Save to temp file
+                temp_path = self._get_temp_audio_path(request_id)
+                if not await self._save_audio_chunk(audio, sample_rate, temp_path):
+                    return {}
+
+                try:
+                    # Run inference in thread pool
+                    result = await asyncio.wait_for(
+                        asyncio.get_event_loop().run_in_executor(
+                            None,
+                            self._run_inference,
+                            temp_path
+                        ),
+                        timeout=self.config.detection_timeout
+                    )
+                    return result
+                finally:
+                    # Cleanup temp file
+                    self._cleanup_temp_file(temp_path)
+
+        except asyncio.TimeoutError:
+            print(f"[EMOTION] Detection timeout for request {request_id}")
+            return {}
+        except Exception as e:
+            print(f"[EMOTION] Detection failed for request {request_id}: {e}")
+            return {}
+        finally:
+            # Remove from active requests
+            with self._request_lock:
+                self._active_requests.pop(request_id, None)
+
+    async def detect_emotions_multi(
+        self,
+        audio: np.ndarray,
+        sample_rate: int,
+        request_id: Optional[str] = None
+    ) -> List[Dict[str, float]]:
+        """
+        Detect emotions from audio with multiple chunks.
+
+        If multi_emotion_per_conversation is enabled, splits audio into
+        chunks and detects emotion for each. Otherwise, uses first chunk only.
+
+        Args:
+            audio: Audio data as numpy array (1D or 2D)
+            sample_rate: Sample rate of audio
+            request_id: Optional request ID for tracking
+
+        Returns:
+            List of dicts, each mapping emotion class to confidence score
+        """
+        if not self.config.enabled:
+            return []
+
+        request_id = request_id or self._generate_request_id()
+
+        # Ensure audio is 1D mono before processing
+        audio = _ensure_mono_1d(audio)
+
+        # Resample if needed
+        if sample_rate != self.config.sample_rate:
+            try:
+                import librosa
+                audio = librosa.resample(
+                    audio.astype(np.float32),
+                    orig_sr=sample_rate,
+                    target_sr=self.config.sample_rate
+                )
+                sample_rate = self.config.sample_rate
+            except Exception as e:
+                print(f"[EMOTION] Resampling failed: {e}")
+                return []
+
+        if not self.config.multi_emotion_per_conversation:
+            # Single chunk mode
+            result = await self.detect_emotion(audio, sample_rate, request_id)
+            return [result] if result else []
+
+        # Multi-chunk mode
+        chunks = self._split_audio_into_chunks(
+            audio, sample_rate, self.config.audio_duration
+        )
+
+        print(f"[EMOTION] Processing {len(chunks)} audio chunks for request {request_id}")
+
+        # Process chunks concurrently
+        tasks = []
+        for i, chunk in enumerate(chunks):
+            chunk_request_id = f"{request_id}_c{i}"
+            tasks.append(self.detect_emotion(chunk, sample_rate, chunk_request_id))
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Filter out failures
+        valid_results = []
+        for result in results:
+            if isinstance(result, dict) and result:
+                valid_results.append(result)
+            elif isinstance(result, Exception):
+                print(f"[EMOTION] Chunk detection failed: {result}")
+
+        return valid_results
+
+    def aggregate_emotions(
+        self,
+        emotion_results: List[Dict[str, float]]
+    ) -> Dict[str, float]:
+        """
+        Aggregate emotions from multiple chunks into single result.
+
+        Uses average confidence across all chunks.
+
+        Args:
+            emotion_results: List of emotion dicts from each chunk
+
+        Returns:
+            Aggregated emotion dict with average confidences
+        """
+        if not emotion_results:
+            return {}
+
+        if len(emotion_results) == 1:
+            return emotion_results[0]
+
+        # Average across all results
+        aggregated = defaultdict(float)
+        for result in emotion_results:
+            for emotion, confidence in result.items():
+                aggregated[emotion] += confidence
+
+        n = len(emotion_results)
+        return {k: v / n for k, v in aggregated.items()}
+
+    async def process_conversation_turn(
+        self,
+        user_id: str,
+        text: str,
+        audio: np.ndarray,
+        sample_rate: int
+    ) -> Tuple[EmotionTurn, bool, str]:
+        """
+        Process a full conversation turn with emotion tracking.
+
+        This is the main entry point for integrating emotion detection
+        into the conversation pipeline.
+
+        Args:
+            user_id: User identifier for tracking
+            text: Transcribed text from STT
+            audio: Audio data (1D or 2D)
+            sample_rate: Sample rate
+
+        Returns:
+            Tuple of:
+            - EmotionTurn object
+            - bool: Whether empathy should be triggered
+            - str: Emotion prompt context (empty if no empathy needed)
+        """
+        if not self.config.enabled or not text.strip():
+            return None, False, ""
+
+        request_id = self._generate_request_id()
+
+        # Log audio shape for debugging
+        print(f"[EMOTION] Processing turn for user {user_id}, request {request_id}, audio shape: {audio.shape}")
+
+        # Detect emotions (multi-chunk if enabled)
+        emotion_results = await self.detect_emotions_multi(audio, sample_rate, request_id)
+
+        if not emotion_results:
+            print(f"[EMOTION] No emotions detected for request {request_id}")
+            return None, False, ""
+
+        # Aggregate results
+        aggregated = self.aggregate_emotions(emotion_results)
+
+        print(f"[EMOTION] Detected emotions: {aggregated}")
+
+        # Record in history
+        turn = self._history.add_turn(
+            user_id=user_id,
+            text=text,
+            emotions=aggregated,
+            negative_classes=self.config.negative_classes,
+            min_confidence_scores=self.config.min_confidence_scores
+        )
+
+        print(f"[EMOTION] Turn recorded - negative majority: {turn.is_negative_majority}")
+
+        # Check if empathy should be triggered
+        should_empathize, negative_turns = self._history.should_trigger_empathy(
+            user_id=user_id,
+            consecutive_threshold=self.config.consecutive_count
+        )
+
+        emotion_prompt = ""
+        if should_empathize:
+            print(f"[EMOTION] Triggering empathetic response for user {user_id}")
+            emotion_prompt = build_emotion_prompt_context(negative_turns)
+
+        return turn, should_empathize, emotion_prompt
+
+    def get_user_emotion_summary(self, user_id: str) -> Dict:
+        """Get emotion summary for a user."""
+        return self._history.get_emotion_summary(user_id)
+
+    def reset_user_emotions(self, user_id: str):
+        """Reset emotion history for a user."""
+        self._history.reset_user_history(user_id)
+
+    def get_active_request_count(self) -> int:
+        """Get count of currently active emotion detection requests."""
+        with self._request_lock:
+            return len(self._active_requests)
+
+
+# Global service instance (lazy loaded)
+_GLOBAL_SERVICE: Optional[EmotionDetectionService] = None
+_SERVICE_LOCK = threading.Lock()
+
+
+def get_emotion_service() -> EmotionDetectionService:
+    """Get the global emotion detection service instance."""
+    global _GLOBAL_SERVICE
+    if _GLOBAL_SERVICE is None:
+        with _SERVICE_LOCK:
+            if _GLOBAL_SERVICE is None:
+                _GLOBAL_SERVICE = EmotionDetectionService()
+    return _GLOBAL_SERVICE
+
+
+def initialize_emotion_service(config: Optional[EmotionConfig] = None) -> EmotionDetectionService:
+    """
+    Initialize or reinitialize the global emotion service.
+
+    Args:
+        config: Optional config. If not provided, loads from .env
+
+    Returns:
+        The initialized service instance
+    """
+    global _GLOBAL_SERVICE
+    with _SERVICE_LOCK:
+        _GLOBAL_SERVICE = EmotionDetectionService(config)
+    return _GLOBAL_SERVICE