1 boceto de v3

backend/app_factory.py

@@ -25,6 +25,7 @@ from repositories.history_repository import (
 from services.chatbot_service import generar_texto_chatbot
 from services.emotion_service import (
     analizar_texto,
+    calcular_valencia_continua,
     calculo_arousal,
     crear_clasificador_emociones,
     estimar_arousal_emocion_es,
@@ -72,6 +73,7 @@ def create_app() -> Flask:
         # Se analiza el texto y se recomiendan peliculas en base a la emocion dominante detectada.
         resultado, dominant_es, dominant_valence = analizar_texto(modelo, texto)
         arousal_actual = calculo_arousal(resultado)
+        valencia_continua = calcular_valencia_continua(resultado)
 
         historial_eventos = obtener_historial_emocional(user_id=user_id, limit=200)
         historico_arousal = [
@@ -91,6 +93,7 @@ def create_app() -> Flask:
             estrategia_recomendacion = estrategia,
             arousal_actual = arousal_actual,
             historico_arousal = historico_arousal,
+            valencia_actual = valencia_continua,
         )
         # Se indica un modo de recomendacion
         recommendation_mode = "diferente" if dominant_es in POSITIVE_EMOTIONS else "similar"
@@ -131,6 +134,7 @@ def create_app() -> Flask:
                 "emociones": resultado,
                 "emocion_dominante": dominant_es,
                 "valencia_dominante": dominant_valence,
+                "valencia_continua": valencia_continua,
                 "arousal_actual": arousal_actual,
                 "historico_arousal_size": len(historico_arousal),
                 "emocion_anterior": emocion_previa.get("emotion") if emocion_previa else None,

backend/services/emotion_service.py

@@ -31,6 +31,16 @@ AROUSAL_BY_EMOTION_ES = {
     "tristeza": 0.3,
 }
 
+VALENCE_BY_MODEL_LABEL = {
+    "joy": 1.0,
+    "surprise": 1.0,
+    "others": 0.5,
+    "sadness": 0.0,
+    "anger": 0.0,
+    "fear": 0.0,
+    "disgust": 0.0,
+}
+
 def mapeo_emocion_valencia(emocion: str) -> str:
     """
     Funcion que mapea una emocion puntual a su valencia (positivo, negativo o neutro) segun las listas de emociones positivas y negativas.
@@ -127,3 +137,27 @@ def calculo_arousal(resultado: list[dict], historical_data: list | None = None)
     return round(max(0.0, min(1.0, arousal_final)), 4)
 
 
+def calcular_valencia_continua(resultado: list[dict]) -> float:
+    """
+    Calcula valencia continua en [0,1] usando toda la distribucion de emociones.
+    0: totalmente negativa, 0.5: neutra, 1: totalmente positiva.
+    """
+    if not resultado:
+        return 0.5
+
+    suma_ponderada = 0.0
+    suma_scores = 0.0
+    for item in resultado:
+        label = str(item.get("label", "others") or "others").strip().lower()
+        score = float(item.get("score", 0.0) or 0.0)
+        peso_valencia = VALENCE_BY_MODEL_LABEL.get(label, 0.5)
+        suma_ponderada += score * peso_valencia
+        suma_scores += score
+
+    if suma_scores <= 0:
+        return 0.5
+
+    valencia = suma_ponderada / suma_scores
+    return round(max(0.0, min(1.0, valencia)), 4)
+
+

backend/services/recommender_service.py

@@ -380,6 +380,92 @@ def _percentil_arousal(arousal_actual: float, historico_arousal: list[float] | N
 
     menores_o_iguales = sum(1 for v in valores if v <= arousal_actual)
     return menores_o_iguales / len(valores)
+
+def _percentil_desde_cero(arousal_actual: float, historico_arousal: list[float] | None) -> float:
+    """
+    Calcula el percentil considerando el 0.0 (calma total) como el ancla inferior.
+    Mide la intensidad absoluta dentro del rango histórico del usuario.
+    """
+    if historico_arousal is None:
+        historico_arousal = []
+
+    # Incluimos el 0.0 explícitamente para que la escala siempre parta de la calma
+    valores = [float(v) for v in historico_arousal if v is not None]
+    valores.append(0.0) 
+    
+    # Ordenamos para entender el rango
+    valores.sort()
+
+    # Si el valor actual es mayor que el máximo histórico, es un 1.0 (máxima intensidad)
+    if arousal_actual >= valores[-1]:
+        return 1.0
+    
+    # Si es menor o igual a 0, es 0.0 (calma total)
+    if arousal_actual <= 0:
+        return 0.0
+
+    # Contamos cuántos valores (incluyendo el 0) quedan por debajo
+    menores = sum(1 for v in valores if v < arousal_actual)
+    
+    # El percentil ahora refleja la distancia desde el "suelo" (0)
+    percentil = menores / len(valores)
+    
+    return round(percentil, 4)
+
+
+def _normalizar_valencia_actual(valencia_actual: str | float | None, emotion_es: str) -> str:
+    """
+    Normaliza valencia a {'positivo', 'negativo', 'neutro'}.
+    Si no se recibe valencia, se infiere desde la emocion actual.
+    """
+    if isinstance(valencia_actual, (int, float)):
+        if float(valencia_actual) > 0.5:
+            return "positivo"
+        if float(valencia_actual) < 0.5:
+            return "negativo"
+        return "neutro"
+
+    val = str(valencia_actual or "").strip().lower()
+    if val in {"positivo", "negativo", "neutro"}:
+        return val
+
+    emo = str(emotion_es or "").strip().lower()
+    if emo == "neutral":
+        return "neutro"
+    if emo in POSITIVE_EMOTIONS:
+        return "positivo"
+    return "negativo"
+
+
+def _valencia_a_factor(valencia_normalizada: str | float | None) -> float:
+    """
+    Mapea valencia a factor numerico V en [0, 1].
+    negativo -> 0.0, neutro -> 0.5, positivo -> 1.0
+    """
+    if isinstance(valencia_normalizada, (int, float)):
+        return max(0.0, min(1.0, float(valencia_normalizada)))
+
+    if valencia_normalizada == "positivo":
+        return 1.0
+    if valencia_normalizada == "negativo":
+        return 0.0
+    return 0.5
+
+def _calcular_pertenencia_zona_confort(peli: dict, zona_confort_ponderada: dict[str, float]) -> float:
+    """
+    Calcula un grado de pertenencia a la zona de confort basado en los generos de la pelicula y su peso en el perfil del usuario.
+    Se devuelve un valor entre 0 y 1, donde 1 significa que la pelicula es completamente dentro de la zona de confort (tiene generos muy preferidos) y 0 significa que esta completamente fuera (no tiene generos preferidos).
+    """
+    generos = _obtener_generos_pelicula(peli)
+    if not generos or not zona_confort_ponderada:
+        return 0.0
+
+    # Se calcula el promedio del peso de los generos de la pelicula segun el perfil del usuario
+    pesos = [zona_confort_ponderada.get(g, 0.0) for g in generos]
+    if not pesos:
+        return 0.0
+
+    return sum(pesos) / len(pesos)
         
 def recomendar_peliculas(
     emotion_es: str,
@@ -390,6 +476,7 @@ def recomendar_peliculas(
     estrategia_recomendacion: str,
     arousal_actual: float = 0.5,
     historico_arousal: list[float] | None = None,
+    valencia_actual: str | float | None = None,
 ) -> list[dict]:
     """
     Funcion principal que recomienda peliculas a un usuario dado su estado emocional y su historial de visualizacion.
@@ -528,7 +615,41 @@ def recomendar_peliculas(
 
 
         case "v3":
-            return "v3"
+            # A = percentil de arousal anclado a calma 0.
+            a = _percentil_desde_cero(arousal_actual, historico_arousal)
+            # V = valencia numerica: negativo=0, neutro=0.5, positivo=1.
+            # Si llega continua, se usa directamente; si llega categorica, se normaliza.
+            if isinstance(valencia_actual, (int, float)):
+                v = _valencia_a_factor(valencia_actual)
+            else:
+                valencia_normalizada = _normalizar_valencia_actual(valencia_actual, emotion_es)
+                v = _valencia_a_factor(valencia_normalizada)
+
+            # Formula propuesta: Cd = 0.5 + A * (0.5 - V)
+            target_confort = 0.5 + a * (0.5 - v)
+            target_confort = max(0.0, min(1.0, target_confort))
+
+            zona_confort_ponderada: dict[str, float] = probabilidades_generos
+
+            def ranking_v3(peli):
+                # A. Grado de confort real de la película (0.0 a 1.0)
+                # Basado en la probabilidad de los géneros en el historial
+                confort_real = _calcular_pertenencia_zona_confort(peli, zona_confort_ponderada)
+                
+                # B. Distancia al Target (Diferencia absoluta)
+                # Queremos que esta distancia sea mínima
+                distancia_al_target = abs(confort_real - target_confort)
+                
+                # C. Factores secundarios
+                emo_score = _score_emo_peli(peli, emotional_scores)
+                calidad = _puntuacion_calidad_global(peli, media_global_ratings)
+
+                # Score Final: Penalizamos la distancia al target y sumamos calidad/emoción
+                # Usamos 1 - distancia para que "menor distancia" sume más
+                return (1 - distancia_al_target) * 0.5 + (emo_score * 0.3) + (calidad * 0.2)
+
+            ranked = sorted(peliculas_candidatas, key=ranking_v3, reverse=True)
+            return ranked[:limit]
 
         case _:
             # Se ordenan por calidad global

readme.txt

@@ -38,4 +38,9 @@ e esto axuda a definir a zona de confort como os generos mais vistos que supoña
 -v2, definense en emotion_service duas funcions (unha para calcular o arousal e outra para pasar a percentil)
     - calculo arousal usase uns pesos predeterminados por emocion, calcula a polaridad do texto usando o que nos devolve a ia e se normaliza
     - ese arousal pasase a un percentil, permitindo saber se a polaridad detectada é habitual no usuario ou non
-    - ahora a maior arousal maior se busca sair da zona de confort se a emocion e positiva (definese unha funcion de forma que o arousal fai que pondere ms) e ao reves se e negativa
+    - ahora a maior arousal maior se busca sair da zona de confort se a emocion e positiva (definese unha funcion de forma que o arousal fai que pondere ms) e ao reves se e negativa
+
+-v3, pasamos de ver a lista de confort como un array de generos, ahora para cada pelicula hai un indice de confort entre 0 e 1.
+    - con percentil desde cero, aseguramos q nn se sempre se esta estresado nn se teña en conta
+    - se e positiva ou negativa, en funcion do arousal buscase un target de indice de confort a buscar nas peliculas
+    - calculase o score como a distancia entre o target e o indice de confort da pelicula