Upload folder using huggingface_hub

.env.example

@@ -11,9 +11,14 @@ ANTHROPIC_API_KEY=
 # Whisper
 WHISPER_MODEL=openai/whisper-small
 WHISPER_MODE=local
+WHISPER_LANGUAGE=ru
 PRELOAD_WHISPER_ON_STARTUP=false
 MAX_AUDIO_DURATION_SECONDS=120
 
+# Emotion portrait (HF model + heuristic hybrid)
+EMOTION_MODE=local
+EMOTION_MODEL=seara/rubert-tiny2-russian-emotion-detection-ru-go-emotions
+
 # Optional MCP bridge for LangGraph tools
 ENABLE_MCP_TOOLS=false
 

README.md

@@ -16,6 +16,8 @@ app_port: 7860
 - Локальная транскрипция через `openai/whisper-small`
 - Озвучка итогов с легкой TTS-моделью (`facebook/mms-tts-rus`) через HF Inference API + mock fallback
 - Карточка речевого портрета (стабильность, скрытое напряжение, триггеры, рекомендация) по 9 транскриптам
+  - Использует HF emotion model: `seara/rubert-tiny2-russian-emotion-detection-ru-go-emotions`
+  - Работает в гибриде: HF-модель + эвристики (устойчиво на CPU free tier)
 - Превью транскрипции и финальная генерация Markdown
 - Опциональный MCP bridge для Tavily/Hugging Face tools
 - Preflight тесты без запуска реальной Whisper (`mock` режим)

app/config.py

@@ -35,6 +35,7 @@ class Settings:
 
     whisper_model: str
     whisper_mode: str
+    whisper_language: Optional[str]
     preload_whisper_on_startup: bool
     max_audio_duration_seconds: int
 
@@ -49,6 +50,8 @@ class Settings:
     tts_model: str
     tts_timeout_seconds: int
     tts_max_chars: int
+    emotion_mode: str
+    emotion_model: str
 
     @classmethod
     def from_env(cls) -> "Settings":
@@ -61,6 +64,7 @@ class Settings:
             llm_model=os.getenv("LLM_MODEL", "gemini-2.5-flash"),
             whisper_model=os.getenv("WHISPER_MODEL", "openai/whisper-small"),
             whisper_mode=os.getenv("WHISPER_MODE", "local"),
+            whisper_language=os.getenv("WHISPER_LANGUAGE", "ru"),
             preload_whisper_on_startup=_env_bool("PRELOAD_WHISPER_ON_STARTUP", False),
             max_audio_duration_seconds=int(os.getenv("MAX_AUDIO_DURATION_SECONDS", "120")),
             enable_mcp_tools=_env_bool("ENABLE_MCP_TOOLS", False),
@@ -74,6 +78,8 @@ class Settings:
             tts_model=os.getenv("TTS_MODEL", "facebook/mms-tts-rus"),
             tts_timeout_seconds=int(os.getenv("TTS_TIMEOUT_SECONDS", "45")),
             tts_max_chars=int(os.getenv("TTS_MAX_CHARS", "900")),
+            emotion_mode=os.getenv("EMOTION_MODE", "local"),
+            emotion_model=os.getenv("EMOTION_MODEL", "seara/rubert-tiny2-russian-emotion-detection-ru-go-emotions"),
         )
 
     @staticmethod

app/main.py

@@ -25,7 +25,7 @@ async def lifespan(app: FastAPI):
 
     mcp_provider = MCPToolProvider(settings)
     llm_service = LLMService(settings, mcp_provider=mcp_provider)
-    portrait_service = PortraitService()
+    portrait_service = PortraitService(settings)
     tts_service = TTSService(settings)
 
     app.state.settings = settings
@@ -49,6 +49,7 @@ app.add_middleware(
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
+    expose_headers=["X-TTS-Source"],
 )
 
 app.include_router(health_router)

app/models/portrait.py

@@ -5,16 +5,29 @@ from pydantic import BaseModel, Field
 
 class PortraitSignal(BaseModel):
     question_number: int
+    round_number: int
+    question_in_round: int
+    question_text: str
     tension: float
     uncertainty: float
     valence: float
 
 
+class PortraitTrigger(BaseModel):
+    question_number: int
+    round_number: int
+    question_in_round: int
+    question_text: str
+    reason: str
+    score: float
+
+
 class PortraitCard(BaseModel):
     emotional_stability: int = Field(ge=1, le=10)
     hidden_tension: int = Field(ge=1, le=10)
     confidence_proxy: int = Field(ge=1, le=10)
     dominant_emotions: List[str] = Field(default_factory=list)
     trigger_questions: List[int] = Field(default_factory=list)
+    triggers: List[PortraitTrigger] = Field(default_factory=list)
     recommendation: str
     signals: List[PortraitSignal] = Field(default_factory=list)

app/routers/health.py

@@ -5,9 +5,12 @@ router = APIRouter(tags=["health"])
 
 @router.get("/health")
 async def health(request: Request):
+    settings = request.app.state.settings
     return {
         "status": "healthy",
         "whisper_loaded": request.app.state.transcription_service.is_loaded,
         "tts_provider": request.app.state.tts_service.provider,
         "tts_available": request.app.state.tts_service.is_available,
+        "emotion_mode": settings.emotion_mode,
+        "emotion_model": settings.emotion_model,
     }

app/services/portrait.py

@@ -3,9 +3,11 @@ from __future__ import annotations
 import math
 import re
 from collections import Counter
-from typing import List
+from functools import lru_cache
+from typing import Any, List
 
-from app.models.portrait import PortraitCard, PortraitSignal
+from app.config import Settings
+from app.models.portrait import PortraitCard, PortraitSignal, PortraitTrigger
 from app.models.session import Answer
 
 _WORD_RE = re.compile(r"[a-zA-Zа-яА-ЯёЁ]+")
@@ -65,6 +67,11 @@ NEGATIVE_MARKERS = (
     "дорог",
 )
 
+TENSION_LABELS = ("anger", "annoyance", "fear", "nervousness", "sadness", "disappointment", "grief", "remorse")
+NEGATIVE_LABELS = ("anger", "annoyance", "fear", "sadness", "disappointment", "grief", "remorse")
+POSITIVE_LABELS = ("joy", "optimism", "gratitude", "love", "approval", "relief", "pride", "admiration")
+UNCERTAINTY_LABELS = ("nervousness", "fear", "confusion", "realization")
+
 
 def _clamp(value: float, lower: float, upper: float) -> float:
     return max(lower, min(upper, value))
@@ -75,7 +82,74 @@ def _count_markers(text: str, markers: tuple[str, ...]) -> int:
     return sum(lowered.count(marker) for marker in markers)
 
 
+def _label_sum(scores: dict[str, float], labels: tuple[str, ...]) -> float:
+    total = 0.0
+    for label, score in scores.items():
+        if any(token in label for token in labels):
+            total += score
+    return _clamp(total, 0.0, 1.0)
+
+
+def _friendly_label(label: str) -> str:
+    mapping = {
+        "joy": "радость",
+        "optimism": "оптимизм",
+        "gratitude": "благодарность",
+        "approval": "уверенность",
+        "nervousness": "волнение",
+        "fear": "тревога",
+        "sadness": "грусть",
+        "anger": "раздражение",
+        "annoyance": "раздражение",
+        "confusion": "сомнение",
+        "neutral": "спокойствие",
+    }
+    return mapping.get(label, label)
+
+
 class PortraitService:
+    def __init__(self, settings: Settings) -> None:
+        self.settings = settings
+        self.mode = settings.emotion_mode.lower().strip()
+
+    @staticmethod
+    @lru_cache(maxsize=1)
+    def _get_classifier(model_name: str):
+        from transformers import pipeline
+
+        return pipeline("text-classification", model=model_name, device="cpu")
+
+    def _model_scores(self, text: str) -> dict[str, float]:
+        if self.mode != "local":
+            return {}
+        if not text.strip():
+            return {}
+
+        try:
+            classifier = self._get_classifier(self.settings.emotion_model)
+            raw: Any = classifier(text[:1200], top_k=None, truncation=True, max_length=512)
+        except Exception:
+            return {}
+
+        rows: list[dict[str, Any]] = []
+        if isinstance(raw, list) and raw:
+            if isinstance(raw[0], dict):
+                rows = [item for item in raw if isinstance(item, dict)]
+            elif isinstance(raw[0], list):
+                nested = raw[0]
+                rows = [item for item in nested if isinstance(item, dict)]
+
+        parsed: dict[str, float] = {}
+        for row in rows:
+            label = str(row.get("label", "")).strip().lower()
+            if not label or label.startswith("label_"):
+                continue
+            score = float(row.get("score", 0.0))
+            if score <= 0:
+                continue
+            parsed[label] = max(parsed.get(label, 0.0), score)
+        return parsed
+
     def _signal_for_answer(self, answer: Answer, index: int) -> tuple[PortraitSignal, list[str]]:
         text = answer.audio_transcript or ""
         tokens = _WORD_RE.findall(text.lower())
@@ -87,25 +161,51 @@ class PortraitService:
         positive_count = _count_markers(text, POSITIVE_MARKERS)
         negative_count = _count_markers(text, NEGATIVE_MARKERS)
 
-        valence = _clamp((positive_count - negative_count) / max(1, positive_count + negative_count), -1.0, 1.0)
-        uncertainty = _clamp((hedge_count - 0.5 * confidence_count) / (token_count / 12 + 1), 0.0, 1.0)
-        tension = _clamp((stress_count + negative_count + 0.7 * hedge_count) / (token_count / 8 + 1), 0.0, 1.0)
-
-        emotions: list[str] = []
-        if tension >= 0.62:
-            emotions.append("напряжение")
-        if uncertainty >= 0.56:
-            emotions.append("осторожность")
-        if valence >= 0.2:
-            emotions.append("оптимизм")
-        elif valence <= -0.2:
-            emotions.append("фрустрация")
+        heuristic_valence = _clamp(
+            (positive_count - negative_count) / max(1, positive_count + negative_count),
+            -1.0,
+            1.0,
+        )
+        heuristic_uncertainty = _clamp((hedge_count - 0.5 * confidence_count) / (token_count / 12 + 1), 0.0, 1.0)
+        heuristic_tension = _clamp((stress_count + negative_count + 0.7 * hedge_count) / (token_count / 8 + 1), 0.0, 1.0)
+
+        scores = self._model_scores(text)
+        has_model_scores = bool(scores)
+
+        if has_model_scores:
+            model_tension = _label_sum(scores, TENSION_LABELS)
+            model_uncertainty = _label_sum(scores, UNCERTAINTY_LABELS)
+            model_positive = _label_sum(scores, POSITIVE_LABELS)
+            model_negative = _label_sum(scores, NEGATIVE_LABELS)
+            model_valence = _clamp(model_positive - model_negative, -1.0, 1.0)
+            tension = _clamp(0.55 * model_tension + 0.45 * heuristic_tension, 0.0, 1.0)
+            uncertainty = _clamp(0.55 * model_uncertainty + 0.45 * heuristic_uncertainty, 0.0, 1.0)
+            valence = _clamp(0.55 * model_valence + 0.45 * heuristic_valence, -1.0, 1.0)
+            top_labels = sorted(scores.items(), key=lambda item: item[1], reverse=True)[:3]
+            emotions = [_friendly_label(label) for label, score in top_labels if score >= 0.14]
+        else:
+            tension = heuristic_tension
+            uncertainty = heuristic_uncertainty
+            valence = heuristic_valence
+            emotions: list[str] = []
+            if tension >= 0.5:
+                emotions.append("напряжение")
+            if uncertainty >= 0.5:
+                emotions.append("осторожность")
+            if valence >= 0.2:
+                emotions.append("оптимизм")
+            elif valence <= -0.2:
+                emotions.append("фрустрация")
+
         if not emotions:
-            emotions.append("спокойствие")
+            emotions = ["спокойствие"]
 
         return (
             PortraitSignal(
                 question_number=index + 1,
+                round_number=answer.round_number,
+                question_in_round=((index % 3) + 1),
+                question_text=answer.question_text,
                 tension=round(tension, 3),
                 uncertainty=round(uncertainty, 3),
                 valence=round(valence, 3),
@@ -121,6 +221,7 @@ class PortraitService:
                 confidence_proxy=6,
                 dominant_emotions=["спокойствие"],
                 trigger_questions=[],
+                triggers=[],
                 recommendation="Недостаточно данных для точного портрета. Нужны ответы на все вопросы.",
                 signals=[],
             )
@@ -130,6 +231,9 @@ class PortraitService:
         tensions: list[float] = []
         uncertainties: list[float] = []
 
+        token_counts = [len(_WORD_RE.findall((answer.audio_transcript or "").lower())) for answer in answers]
+        avg_token_count = sum(token_counts) / len(token_counts)
+
         for idx, answer in enumerate(answers):
             signal, emotions = self._signal_for_answer(answer, idx)
             signals.append(signal)
@@ -146,25 +250,50 @@ class PortraitService:
         variance = sum((value - mean_tension) ** 2 for value in tensions) / len(tensions)
         stdev = math.sqrt(variance)
 
-        emotional_stability = round(_clamp(10 - (stdev * 14 + avg_jump * 10), 1, 10))
-        hidden_tension = round(_clamp(mean_tension * 10 + max(0.0, stdev - 0.12) * 10, 1, 10))
-        confidence_proxy = round(_clamp((1 - mean_uncertainty) * 10, 1, 10))
-
-        top_tension = sorted(signals, key=lambda item: item.tension, reverse=True)
-        trigger_questions = [item.question_number for item in top_tension if item.tension >= 0.35][:2]
-        if len(trigger_questions) < 2:
-            for item in top_tension:
-                if item.question_number not in trigger_questions:
-                    trigger_questions.append(item.question_number)
-                if len(trigger_questions) == 2:
+        stability_raw = _clamp(1 - (stdev * 1.7 + avg_jump * 1.15), 0.0, 1.0)
+        tension_raw = _clamp(mean_tension * 0.9 + max(0.0, stdev - 0.11) * 1.05, 0.0, 1.0)
+        short_answer_penalty = 0.22 if avg_token_count < 5 else 0.0
+        confidence_raw = _clamp((1 - mean_uncertainty) - short_answer_penalty, 0.0, 1.0)
+
+        emotional_stability = round(_clamp(2.5 + stability_raw * 6.0, 1, 10))
+        hidden_tension = round(_clamp(2.0 + tension_raw * 6.0, 1, 10))
+        confidence_proxy = round(_clamp(2.0 + confidence_raw * 6.0, 1, 10))
+
+        peak_tension = max(tensions) if tensions else 0.0
+        peak_uncertainty = max(uncertainties) if uncertainties else 0.0
+        triggers: list[PortraitTrigger] = []
+
+        if peak_tension >= 0.3 or peak_uncertainty >= 0.34:
+            top_signals = sorted(signals, key=lambda item: max(item.tension, item.uncertainty), reverse=True)
+            trigger_threshold = max(0.32, mean_tension + 0.08)
+            for signal in top_signals:
+                peak_score = max(signal.tension, signal.uncertainty)
+                if peak_score < trigger_threshold:
+                    continue
+                reason = "рост напряжения" if signal.tension >= signal.uncertainty else "рост неопределенности"
+                triggers.append(
+                    PortraitTrigger(
+                        question_number=signal.question_number,
+                        round_number=signal.round_number,
+                        question_in_round=signal.question_in_round,
+                        question_text=signal.question_text,
+                        reason=reason,
+                        score=round(peak_score, 3),
+                    )
+                )
+                if len(triggers) == 2:
                     break
 
+        trigger_questions = [item.question_number for item in triggers]
+
         if hidden_tension >= 7:
             recommendation = "Говорить медленнее в стресс-темах: там растут маркеры напряжения и неопределенности."
         elif confidence_proxy <= 4:
             recommendation = "Уточнять формулировки короче и конкретнее: сейчас много осторожных оговорок."
+        elif not triggers:
+            recommendation = "Сохранять текущий темп: резких эмоциональных триггеров по ответам не выявлено."
         else:
-            recommendation = "Сохранять текущий темп и добавить больше конкретных цифр в ключевых ответах."
+            recommendation = "Добавить больше конкретики в триггерных вопросах и фиксировать метрики сразу в ответе."
 
         dominant_emotions = [label for label, _ in emotion_counter.most_common(3)]
 
@@ -174,6 +303,7 @@ class PortraitService:
             confidence_proxy=confidence_proxy,
             dominant_emotions=dominant_emotions,
             trigger_questions=trigger_questions,
+            triggers=triggers,
             recommendation=recommendation,
             signals=signals,
         )

app/services/transcription.py

@@ -54,7 +54,11 @@ class TranscriptionService:
                 self._pipeline = self._get_pipeline(self.settings.whisper_model)
                 self._loaded = True
 
-            result = self._pipeline(str(wav_path))
+            generate_kwargs = {"task": "transcribe"}
+            if self.settings.whisper_language:
+                generate_kwargs["language"] = self.settings.whisper_language
+
+            result = self._pipeline(str(wav_path), generate_kwargs=generate_kwargs)
             return result["text"].strip()
         finally:
             if wav_path.exists():

scripts/preflight.sh

@@ -7,6 +7,7 @@ export WHISPER_MODE=mock
 export PRELOAD_WHISPER_ON_STARTUP=false
 export TTS_PROVIDER=mock
 export LLM_PROVIDER=mock
+export EMOTION_MODE=mock
 unset GEMINI_API_KEY
 unset ANTHROPIC_API_KEY
 unset HUGGINGFACE_API_KEY

tests/conftest.py

@@ -8,6 +8,7 @@ os.environ["PRELOAD_WHISPER_ON_STARTUP"] = "false"
 os.environ["TTS_PROVIDER"] = "mock"
 os.environ["TTS_MODEL"] = "facebook/mms-tts-rus"
 os.environ["LLM_PROVIDER"] = "mock"
+os.environ["EMOTION_MODE"] = "mock"
 os.environ.pop("ANTHROPIC_API_KEY", None)
 os.environ.pop("HUGGINGFACE_API_KEY", None)
 os.environ.pop("GEMINI_API_KEY", None)

tests/test_api_flow.py

@@ -66,6 +66,7 @@ def test_full_9_question_flow_and_results(client):
     assert 1 <= results_payload["portrait"]["emotional_stability"] <= 10
     assert 1 <= results_payload["portrait"]["hidden_tension"] <= 10
     assert isinstance(results_payload["portrait"]["trigger_questions"], list)
+    assert isinstance(results_payload["portrait"]["triggers"], list)
 
     download = client.get(f"/api/session/{session_id}/download")
     assert download.status_code == 200

tests/test_preflight_unittest.py

@@ -9,6 +9,7 @@ os.environ["PRELOAD_WHISPER_ON_STARTUP"] = "false"
 os.environ["TTS_PROVIDER"] = "mock"
 os.environ["TTS_MODEL"] = "facebook/mms-tts-rus"
 os.environ["LLM_PROVIDER"] = "mock"
+os.environ["EMOTION_MODE"] = "mock"
 os.environ.pop("ANTHROPIC_API_KEY", None)
 os.environ.pop("HUGGINGFACE_API_KEY", None)
 os.environ.pop("GEMINI_API_KEY", None)