Inclusion de zona de confort

Funciones de calculo de zona de confort y comprobacion de si las peliculas pertenecen a esta

backend/services/recommender_service.py

@@ -252,6 +252,61 @@ def _puntuacion_preferencia_personal(
 
     return _similitud_con_historial(row, generos_referencia)
 
+def _distancia_zona_confort(
+    row: dict,
+    zona_confort: set[str],
+    ranking_generos: dict[str, int],
+) -> float:
+    """
+    Funcion que calcula la distancia de una pelicula a la zona de confort del usuario
+    Si una pelicula contiene generos de zona comfort d = 0
+    En caso contrario, se queda con el genero de menor distancia
+
+    Args:
+        - row: pelicula de referencia a estudiar
+        - zona_confort: set con los dos generos mas vistos por el usuario
+        - ranking_generos: diccionario con los generos ordenados de mayor a menor por num de visualizaciones
+    Returns:
+        - Float que indica la distancia a la zona de confort de la pelicula
+    """
+
+    generos_pelicula = _obtener_generos_pelicula(row)
+    if not generos_pelicula or not ranking_generos:
+        return 1.0 # Si no hay generos asociados a la pelicula o ranking se devuelve la mayor d posible
+
+    # Si esta dentro de la zona de confort la distancia es cero
+    if generos_pelicula & zona_confort: # Se obtiene la interseccion de los dos conjuntos
+        return 0.0
+
+    # Si no esta dentro de la zona de confort se debe calcular la distancia
+    # Para cada genero de row se obtiene su pos en el ranking del usuario
+    ranking = [ranking_generos[g] for g in generos_pelicula if g  in ranking_generos]
+    if not ranking:
+        return 1.0 # No hay ningun genero en comun
+    min_rank = min(ranking) # Se coje el genero mas proximo a la zona de confort
+    d = max(0, min_rank - 1) # Nos aseguramos de no tener distancias negativas
+    # Se normaliza a un valor entre cero y uno
+    max_posible = max(1, len(ranking_generos) - 1)
+    return d / max_posible
+
+def _esta_zona_confort(row: dict, zona_confort: set[str]) -> bool:
+    """
+    Funcion que se encarga de comprobar si una pelicula pertenece o no a la zona de confort
+
+    Args:
+        - row: pelicula a comprobar si esta en el conjunto
+        - zona_confort: top 2 generos mas vistos del usuario
+    Returns:
+        - Boolean si la pelicula tiene generos dentro de la zona de confort del usuario
+    """
+    # Si no existe zona de confort la pelicula no puede estar en ella
+    if not zona_confort: 
+        return False
+    else:
+        generos = _obtener_generos_pelicula(row)
+        # Se devuelve si existe interseccion de los dos conjuntos
+        return bool(generos & zona_confort)
+    
 
 def recomendar_peliculas(
     emotion_es: str,
@@ -286,6 +341,13 @@ def recomendar_peliculas(
     generos_gustados = set(contador_generos_gustados.keys()) # Conjunto de generos que el usuario ha valorado positivamente
     tiene_historial = len(peliculas_vistas) > 0 # Indicador de si el usuario tiene historial de visualizacion
 
+    # Creacion de la zona de comfort (2 generos mas vistos)
+    # Se devuelve los generos ordenados por frecuencia usando most.common() de la clase Counter
+    top_generos = [g for g, _ in contador_generos_vistos.most_common()]
+    zona_confort = set[top_generos[:2] # La zona de confort son los dos generos mas visitados
+    # Se convierte el ranking a un diccionario donde la clave es el genero y el valor su posicion en el ranking
+    ranking_generos = {g:i for i, g in enumerate(top_generos)}
+
     peliculas_no_vistas = [row for row in movies_df if str(row.get("movieId", "")).strip() not in peliculas_vistas]
     # Si el usuario tiene historial, se recomienda entre las peliculas no vistas; si no tiene historial, se recomienda entre todas las peliculas.
     peliculas_candidatas = peliculas_no_vistas if peliculas_no_vistas else movies_df
@@ -309,32 +371,91 @@ def recomendar_peliculas(
         # Se seleccionan aleatoriamente del pool para fomentar diversidad entre usuarios sin historial, evitando recomendar siempre las mismas peliculas.
         return random.sample(candidate_pool, k=limit)
 
+    if tiene_historial and zona_confort:
+        candidatas_confort = [r for r in peliculas_candidatas if _esta_zona_confort(r, zona_confort)]
+        if candidatas_confort:
+            peliculas_candidatas = candidatas_confort
+
+    # En caso de SI HABER HISTORIAL se comprobara si la emocion es positiva o negativa
     is_positive = emotion_es in POSITIVE_EMOTIONS
 
     if is_positive:
         # Emocion positiva: mayor peso a novedad sin perder calidad.
-        # La proporcion es 0.25 para preferencia personal, 0.30 para calidad global y 0.45 para diversidad 
+        # La proporcion es 0.25 para preferencia personal, 0.30 para calidad global, 0.20 para diversidad + 0.25 para d zona de confort 
+        """ranked = sorted(
+            peliculas_candidatas,
+            key=lambda r: (
+                0.25 * _puntuacion_preferencia_personal(r, medias_rating_por_genero, generos_vistos)
+                + 0.30 * _puntuacion_calidad_global(r, media_global_ratings)
+                + 0.20 * (1.0 - _similitud_con_historial(r, generos_vistos))
+                + 0.25 * _distancia_zona_confort(r, zona_confort, ranking_generos)
+            ),
+            reverse=True,
+        )
+        
+        # Ahora pasa a usar directamente la distancia a la zona de confort
         ranked = sorted(
             peliculas_candidatas,
             key=lambda r: (
                 0.25 * _puntuacion_preferencia_personal(r, medias_rating_por_genero, generos_vistos)
                 + 0.30 * _puntuacion_calidad_global(r, media_global_ratings)
-                + 0.45 * (1.0 - _similitud_con_historial(r, generos_vistos))
+                + 0.45 * _distancia_a_comfort_zone(r, comfort_genres, genre_rank)  # más lejos del top2 => mejor
+            ),
+            reverse=True,
+        )"""
+
+        # 1) filtrar fuera del top2
+        outside = [r for r in peliculas_candidatas if not (_obtener_generos_pelicula(r) & comfort_genres)]
+    
+        # fallback si el filtro deja vacío
+        base = outside if outside else peliculas_candidatas
+    
+        # 2) ordenar por (más lejos del top2) y desempatar por calidad
+        ranked = sorted(
+            base,
+            key=lambda r: (
+                _distancia_a_top2(r, comfort_genres, genre_rank),
+                _puntuacion_calidad_global(r, media_global_ratings),
             ),
             reverse=True,
         )
     else:
+        """
         # Emocion negativa: mayor peso a preferencia personal + similitud.
-        # La proporcion es 0.55 para preferencia personal, 0.30 para calidad global y 0.15 para similitud con historial.
+        # La proporcion es 0.55 para preferencia personal, 0.30 para calidad global, 0.05 para similitud con historial y 0.15 para zona confort
         reference_genres = generos_gustados if generos_gustados else generos_vistos
         ranked = sorted(
             peliculas_candidatas,
             key=lambda r: (
                 0.55 * _puntuacion_preferencia_personal(r, medias_rating_por_genero, reference_genres)
-                + 0.30 * _puntuacion_calidad_global(r, media_global_ratings)
-                + 0.15 * _similitud_con_historial(r, reference_genres)
+                + 0.25 * _puntuacion_calidad_global(r, media_global_ratings)
+                + 0.05 * _similitud_con_historial(r, reference_genres)
+                + 0.15 * (1.0 - _distancia_zona_confort(r, zona_confort, ranking_generos)
             ),
             reverse=True,
         )
 
+        ranked = sorted(
+            peliculas_candidatas,
+            key=lambda r: (
+                0.55 * _puntuacion_preferencia_personal(r, medias_rating_por_genero, reference_genres)
+                + 0.30 * _puntuacion_calidad_global(r, media_global_ratings)
+                + 0.15 * (1.0 - _distancia_a_comfort_zone(r, comfort_genres, genre_rank))  # más cerca del top2 => mejor
+            ),
+            reverse=True,
+        )"""
+        
+    # 1) filtrar dentro del top2
+    inside = [r for r in peliculas_candidatas if _obtener_generos_pelicula(r) & zona_confort]
+
+    # fallback si el filtro deja vacío
+    base = inside if inside else peliculas_candidatas
+
+    # 2) ordenar por calidad global
+    ranked = sorted(
+        base,
+        key=lambda r: _puntuacion_calidad_global(r, media_global_ratings),
+        reverse=True,
+    )
+
     return ranked[:limit]