import os import pandas as pd import numpy as np from sentence_transformers import SentenceTransformer from sklearn.neighbors import NearestNeighbors from sklearn.decomposition import TruncatedSVD, NMF from sklearn.metrics.pairwise import cosine_similarity, euclidean_distances from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.cluster import KMeans from sklearn.preprocessing import StandardScaler from scipy.sparse import csr_matrix from scipy.spatial.distance import pdist, squareform import gradio as gr import json import re from collections import defaultdict, Counter import csv import time from datetime import datetime import warnings warnings.filterwarnings('ignore') # Importar huggingface_hub para descargar archivos from huggingface_hub import hf_hub_download # ==================== CARGA DE DATOS DESDE HUGGING FACE ==================== def download_file_from_hf(filename, repo_id="aegarciaherrera/Sistema_Recomendador_Archivos"): """ Descarga un archivo específico desde el repositorio de Hugging Face """ try: file_path = hf_hub_download( repo_id=repo_id, filename=filename, repo_type="dataset" ) print(f"✓ Archivo {filename} descargado exitosamente") return file_path except Exception as e: print(f"✗ Error descargando {filename}: {str(e)}") return None # Descargar archivos principales print("Descargando archivos desde Hugging Face...") productos_path = download_file_from_hf("productos.csv") mapping_path = download_file_from_hf("embedding_index_mapping.csv") # Cargar datos principales if productos_path and mapping_path: df_productos = pd.read_csv(productos_path) df_productos = df_productos.reset_index(drop=True) df_mapping = pd.read_csv(mapping_path) print(f"✓ Productos cargados: {len(df_productos):,} registros") print(f"✓ Mapping cargado: {len(df_mapping):,} registros") else: raise FileNotFoundError("No se pudieron descargar los archivos principales") # Cargar ratings (adaptable a ambos formatos) try: # Intentar cargar ratings agregados (V2) ratings_agg_path = download_file_from_hf("ratings_aggregated.csv") ratings_det_path = download_file_from_hf("ratings_detailed.csv") if ratings_agg_path and ratings_det_path: df_ratings_aggregated = pd.read_csv(ratings_agg_path) df_ratings_detailed = pd.read_csv(ratings_det_path) ratings_dict = df_ratings_aggregated.set_index('parent_asin')['average_rating'].to_dict() print(f"✓ Ratings V2 cargados: {len(ratings_dict):,} productos con ratings") HAS_DETAILED_RATINGS = True else: raise FileNotFoundError("Archivos V2 no encontrados") except Exception as e: print(f"No se pudieron cargar ratings V2: {str(e)}") try: # Fallback a ratings V1 ratings_path = download_file_from_hf("ratings.csv") if ratings_path: df_ratings = pd.read_csv(ratings_path) ratings_dict = df_ratings.set_index('parent_asin')['rating'].to_dict() df_ratings_detailed = df_ratings # Para compatibilidad print(f"✓ Ratings V1 cargados: {len(ratings_dict):,} productos con ratings") HAS_DETAILED_RATINGS = False else: raise FileNotFoundError("No se pudo cargar ratings V1") except Exception as e2: print(f"✗ Error cargando ratings: {str(e2)}") ratings_dict = {} df_ratings_detailed = pd.DataFrame() HAS_DETAILED_RATINGS = False print("=" * 50) print("RESUMEN DE CARGA:") print(f"- Productos: {len(df_productos):,} registros") print(f"- Ratings: {len(ratings_dict):,} productos") print(f"- Ratings detallados: {'Sí' if HAS_DETAILED_RATINGS else 'No'}") print("=" * 50) # ==================== PREPARACIÓN DE DATOS (SIN MERGE) ==================== # CRÍTICO: No hacer merge para preservar embeddings precargados df_similars = df_productos[df_productos["parent_asin"].isin(df_mapping["parent_asin"])].reset_index(drop=True) # Asegurarte de que el orden coincida df_similars = df_similars.merge(df_mapping, on="parent_asin").sort_values("index").reset_index(drop=True) # CRÍTICO: Resetear índices ANTES de cualquier operación df_similars["description"] = df_similars["description"].fillna("").astype(str) df_similars = df_similars.reset_index(drop=True) print(f"Total de productos en df_similars: {len(df_similars):,}") print(f"Productos únicos: {df_similars['parent_asin'].nunique():,}") # ==================== CARGA DE EMBEDDINGS ==================== model = SentenceTransformer("all-MiniLM-L6-v2") # Descargar embeddings precomputados desde Hugging Face try: embeddings_path = download_file_from_hf("embeddings.npy") descriptions_path = download_file_from_hf("descriptions.npy") if embeddings_path and descriptions_path: description_embeddings = np.load(embeddings_path) descriptions = np.load(descriptions_path, allow_pickle=True) print(f"✓ Embeddings precalculados descargados y cargados: {description_embeddings.shape}") # VERIFICACIÓN CRÍTICA: Asegurar consistencia if len(description_embeddings) != len(df_similars): print(f"WARNING: Mismatch detectado!") print(f" Embeddings: {len(description_embeddings)}") print(f" df_similars: {len(df_similars)}") print(" Recomiendo regenerar embeddings con el nuevo df_similars") else: print("✓ Consistencia verificada: embeddings y df_similars coinciden") else: raise FileNotFoundError("No se pudieron descargar los embeddings precomputados") except Exception as e: print(f"✗ Error descargando embeddings: {str(e)}") print("Generando embeddings básicos...") description_embeddings = model.encode(df_similars["description"].tolist()) descriptions = df_similars["description"].values # ==================== SISTEMA DE MÉTRICAS Y EVALUACIÓN ==================== class RecommendationMetrics: """Sistema de métricas para evaluar y comparar diferentes enfoques de recomendación""" def __init__(self): self.metrics_history = defaultdict(list) self.execution_times = defaultdict(list) def calculate_diversity(self, recommendations_asins): """Calcula la diversidad de las recomendaciones basada en categorías""" if not recommendations_asins: return 0.0 categories = [] for asin in recommendations_asins: product_row = df_similars[df_similars['parent_asin'] == asin] if len(product_row) > 0: category = product_row.iloc[0].get('main_category', 'Unknown') categories.append(category) if not categories: return 0.0 unique_categories = len(set(categories)) total_items = len(categories) return unique_categories / total_items def calculate_novelty(self, recommendations_asins): """Calcula la novedad basada en popularidad (rating y frecuencia)""" if not recommendations_asins: return 0.0 novelty_scores = [] for asin in recommendations_asins: rating = ratings_dict.get(asin, 0.0) # Mayor rating = menor novedad (productos populares) novelty_score = max(0, 5.0 - rating) / 5.0 novelty_scores.append(novelty_score) return np.mean(novelty_scores) if novelty_scores else 0.0 def calculate_coverage(self, recommendations_asins, total_available_items): """Calcula el coverage como porcentaje de items únicos recomendados""" unique_recommendations = len(set(recommendations_asins)) return unique_recommendations / min(total_available_items, 100) # Normalizar def calculate_precision_at_k(self, recommendations_asins, relevant_items, k=5): """Calcula precision@k""" if not recommendations_asins or not relevant_items: return 0.0 top_k = recommendations_asins[:k] relevant_in_top_k = len(set(top_k) & set(relevant_items)) return relevant_in_top_k / min(k, len(top_k)) def evaluate_recommendations(self, method_name, recommendations_asins, execution_time, relevant_items=None, total_available=1000): """Evalúa un conjunto de recomendaciones con múltiples métricas""" metrics = { 'method': method_name, 'timestamp': datetime.now(), 'execution_time': execution_time, 'num_recommendations': len(recommendations_asins), 'diversity': self.calculate_diversity(recommendations_asins), 'novelty': self.calculate_novelty(recommendations_asins), 'coverage': self.calculate_coverage(recommendations_asins, total_available) } if relevant_items: metrics['precision_at_5'] = self.calculate_precision_at_k(recommendations_asins, relevant_items, 5) # Almacenar métricas for key, value in metrics.items(): if key not in ['method', 'timestamp']: self.metrics_history[f"{method_name}_{key}"].append(value) return metrics def get_comparison_report(self): """Genera un reporte comparativo de todos los métodos evaluados""" if not self.metrics_history: return "No hay métricas disponibles" report = "# 📊 REPORTE COMPARATIVO DE MÉTODOS\n\n" # Agrupar métricas por tipo methods = set() for key in self.metrics_history.keys(): method = key.split('_')[0] + '_' + key.split('_')[1] methods.add(method) for method in sorted(methods): report += f"## {method.replace('_', ' ').title()}\n" # Buscar métricas de este método method_metrics = {} for key, values in self.metrics_history.items(): if key.startswith(method): metric_name = '_'.join(key.split('_')[2:]) if values: method_metrics[metric_name] = { 'mean': np.mean(values), 'std': np.std(values), 'count': len(values) } for metric, stats in method_metrics.items(): report += f"- **{metric.replace('_', ' ').title()}**: {stats['mean']:.4f} ± {stats['std']:.4f} (n={stats['count']})\n" report += "\n" return report # Instancia global de métricas metrics_evaluator = RecommendationMetrics() # ==================== FUNCIONALIDAD 1: BÚSQUEDA POR DESCRIPCIÓN (3 MÉTODOS) ==================== class DescriptionSearcher: """Sistema de búsqueda por descripción con múltiples enfoques""" def __init__(self, df_products, embeddings, model): self.df_products = df_products self.embeddings = embeddings self.model = model self.setup_methods() def setup_methods(self): """Configura los diferentes métodos de búsqueda""" # Método 1: KNN con embeddings (original) self.knn = NearestNeighbors(n_neighbors=50, metric="cosine") self.knn.fit(self.embeddings) # Método 2: TF-IDF + Cosine Similarity descriptions_text = self.df_products["description"].fillna("").tolist() self.tfidf_vectorizer = TfidfVectorizer( max_features=5000, stop_words='english', ngram_range=(1, 2), min_df=2 ) self.tfidf_matrix = self.tfidf_vectorizer.fit_transform(descriptions_text) # Método 3: Clustering + Embedding similarity self.n_clusters = min(100, len(self.df_products) // 10) self.kmeans = KMeans(n_clusters=self.n_clusters, random_state=42, n_init=10) self.cluster_labels = self.kmeans.fit_predict(self.embeddings) def search_method_1_knn(self, query, n_results=5): """Método 1: KNN con embeddings (original mejorado)""" start_time = time.time() query_embedding = self.model.encode([query]) distances, indices = self.knn.kneighbors(query_embedding, n_neighbors=min(50, len(self.df_products))) results = [] seen_asins = set() for i, idx in enumerate(indices[0]): if len(results) >= n_results: break if idx >= len(self.df_products): continue row = self.df_products.iloc[idx] asin = row.get("parent_asin", "N/A") if asin in seen_asins: continue seen_asins.add(asin) similarity_score = 1 - distances[0][i] # Convertir distancia a similitud results.append({ 'asin': asin, 'similarity_score': similarity_score, 'method': 'KNN_Embeddings' }) execution_time = time.time() - start_time # Evaluar con métricas result_asins = [r['asin'] for r in results] metrics = metrics_evaluator.evaluate_recommendations( 'search_knn', result_asins, execution_time ) return results, metrics def search_method_2_tfidf(self, query, n_results=5): """Método 2: TF-IDF + Cosine Similarity""" start_time = time.time() query_tfidf = self.tfidf_vectorizer.transform([query]) similarities = cosine_similarity(query_tfidf, self.tfidf_matrix).flatten() # Obtener top resultados top_indices = np.argsort(similarities)[::-1] results = [] seen_asins = set() for idx in top_indices: if len(results) >= n_results: break if similarities[idx] < 0.01: # Umbral mínimo de similitud continue row = self.df_products.iloc[idx] asin = row.get("parent_asin", "N/A") if asin in seen_asins: continue seen_asins.add(asin) results.append({ 'asin': asin, 'similarity_score': similarities[idx], 'method': 'TF_IDF' }) execution_time = time.time() - start_time # Evaluar con métricas result_asins = [r['asin'] for r in results] metrics = metrics_evaluator.evaluate_recommendations( 'search_tfidf', result_asins, execution_time ) return results, metrics def search_method_3_cluster(self, query, n_results=5): """Método 3: Clustering + Embedding similarity""" start_time = time.time() query_embedding = self.model.encode([query]) # Encontrar cluster más similar query_cluster = self.kmeans.predict(query_embedding)[0] # Filtrar productos del mismo cluster cluster_mask = self.cluster_labels == query_cluster cluster_indices = np.where(cluster_mask)[0] if len(cluster_indices) == 0: execution_time = time.time() - start_time return [], {'method': 'Cluster_Search', 'execution_time': execution_time} # Calcular similitudes dentro del cluster cluster_embeddings = self.embeddings[cluster_indices] similarities = cosine_similarity(query_embedding, cluster_embeddings).flatten() # Ordenar por similitud sorted_cluster_indices = cluster_indices[np.argsort(similarities)[::-1]] results = [] seen_asins = set() for idx in sorted_cluster_indices: if len(results) >= n_results: break row = self.df_products.iloc[idx] asin = row.get("parent_asin", "N/A") if asin in seen_asins: continue seen_asins.add(asin) similarity_idx = np.where(cluster_indices == idx)[0][0] similarity_score = similarities[similarity_idx] results.append({ 'asin': asin, 'similarity_score': similarity_score, 'method': 'Cluster_Search' }) execution_time = time.time() - start_time # Evaluar con métricas result_asins = [r['asin'] for r in results] metrics = metrics_evaluator.evaluate_recommendations( 'search_cluster', result_asins, execution_time ) return results, metrics # ==================== FUNCIONALIDAD 2: RECOMENDACIÓN COLABORATIVA (3 MÉTODOS) ==================== class CollaborativeRecommender: """Sistema de recomendación colaborativa con múltiples enfoques""" def __init__(self, ratings_df, min_ratings_per_user=5, min_ratings_per_item=5): self.ratings_df = ratings_df.copy() self.min_ratings_per_user = min_ratings_per_user self.min_ratings_per_item = min_ratings_per_item self.user_item_matrix = None self.item_similarity_matrix = None self.svd_model = None self.nmf_model = None self.user_encoder = {} self.item_encoder = {} self.user_decoder = {} self.item_decoder = {} self._prepare_data() self._build_matrices() def _prepare_data(self): """Prepara los datos filtrando usuarios e items con pocas interacciones""" print("Preparando datos para filtrado colaborativo...") # Filtrar usuarios con al menos min_ratings_per_user ratings user_counts = self.ratings_df['user_id'].value_counts() valid_users = user_counts[user_counts >= self.min_ratings_per_user].index # Filtrar items con al menos min_ratings_per_item ratings item_counts = self.ratings_df['parent_asin'].value_counts() valid_items = item_counts[item_counts >= self.min_ratings_per_item].index # Aplicar filtros self.ratings_df = self.ratings_df[ (self.ratings_df['user_id'].isin(valid_users)) & (self.ratings_df['parent_asin'].isin(valid_items)) ] print(f"Datos filtrados: {len(self.ratings_df):,} ratings, " f"{self.ratings_df['user_id'].nunique():,} usuarios, " f"{self.ratings_df['parent_asin'].nunique():,} productos") # Crear encoders unique_users = self.ratings_df['user_id'].unique() unique_items = self.ratings_df['parent_asin'].unique() self.user_encoder = {user: idx for idx, user in enumerate(unique_users)} self.item_encoder = {item: idx for idx, item in enumerate(unique_items)} self.user_decoder = {idx: user for user, idx in self.user_encoder.items()} self.item_decoder = {idx: item for item, idx in self.item_encoder.items()} def _build_matrices(self): """Construye las matrices necesarias para la recomendación""" print("Construyendo matrices de interacción...") n_users = len(self.user_encoder) n_items = len(self.item_encoder) # Mapear a índices numéricos user_indices = self.ratings_df['user_id'].map(self.user_encoder) item_indices = self.ratings_df['parent_asin'].map(self.item_encoder) ratings = self.ratings_df['rating'].values # Crear matriz sparse self.user_item_matrix = csr_matrix( (ratings, (user_indices, item_indices)), shape=(n_users, n_items) ) # Método 1: SVD para similitud entre items print("Calculando similitudes SVD...") self.svd_model = TruncatedSVD( n_components=min(50, min(n_users, n_items)-1), random_state=42 ) item_features_svd = self.svd_model.fit_transform(self.user_item_matrix.T) self.item_similarity_matrix = cosine_similarity(item_features_svd) # Método 2: NMF para factorización print("Calculando factorización NMF...") self.nmf_model = NMF( n_components=min(30, min(n_users, n_items)-1), random_state=42, max_iter=200 ) self.user_features_nmf = self.nmf_model.fit_transform(self.user_item_matrix) self.item_features_nmf = self.nmf_model.components_.T # Método 3: Item-based cosine similarity directo print("Calculando similitud directa...") self.item_similarity_direct = cosine_similarity(self.user_item_matrix.T) print("Matrices construidas exitosamente") def recommend_method_1_svd(self, target_item, n_recommendations=4): """Método 1: Recomendaciones basadas en SVD""" start_time = time.time() if target_item not in self.item_encoder: return [], {'method': 'SVD_Collaborative', 'execution_time': 0} target_idx = self.item_encoder[target_item] similarities = self.item_similarity_matrix[target_idx] # Obtener items más similares (excluyendo el item objetivo) similar_indices = np.argsort(similarities)[::-1][1:n_recommendations+1] recommendations = [] for idx in similar_indices: item_id = self.item_decoder[idx] similarity_score = similarities[idx] recommendations.append({ 'asin': item_id, 'similarity_score': similarity_score, 'method': 'SVD_Collaborative' }) execution_time = time.time() - start_time # Evaluar con métricas result_asins = [r['asin'] for r in recommendations] metrics = metrics_evaluator.evaluate_recommendations( 'collab_svd', result_asins, execution_time ) return recommendations, metrics def recommend_method_2_nmf(self, target_item, n_recommendations=4): """Método 2: Recomendaciones basadas en NMF""" start_time = time.time() if target_item not in self.item_encoder: return [], {'method': 'NMF_Collaborative', 'execution_time': 0} target_idx = self.item_encoder[target_item] target_features = self.item_features_nmf[target_idx] # Calcular similitudes con todos los items similarities = cosine_similarity([target_features], self.item_features_nmf).flatten() # Obtener items más similares (excluyendo el item objetivo) similar_indices = np.argsort(similarities)[::-1][1:n_recommendations+1] recommendations = [] for idx in similar_indices: item_id = self.item_decoder[idx] similarity_score = similarities[idx] recommendations.append({ 'asin': item_id, 'similarity_score': similarity_score, 'method': 'NMF_Collaborative' }) execution_time = time.time() - start_time # Evaluar con métricas result_asins = [r['asin'] for r in recommendations] metrics = metrics_evaluator.evaluate_recommendations( 'collab_nmf', result_asins, execution_time ) return recommendations, metrics def recommend_method_3_direct(self, target_item, n_recommendations=4): """Método 3: Similitud directa item-to-item""" start_time = time.time() if target_item not in self.item_encoder: return [], {'method': 'Direct_Collaborative', 'execution_time': 0} target_idx = self.item_encoder[target_item] similarities = self.item_similarity_direct[target_idx] # Obtener items más similares (excluyendo el item objetivo) similar_indices = np.argsort(similarities)[::-1][1:n_recommendations+1] recommendations = [] for idx in similar_indices: item_id = self.item_decoder[idx] similarity_score = similarities[idx] recommendations.append({ 'asin': item_id, 'similarity_score': similarity_score, 'method': 'Direct_Collaborative' }) execution_time = time.time() - start_time # Evaluar con métricas result_asins = [r['asin'] for r in recommendations] metrics = metrics_evaluator.evaluate_recommendations( 'collab_direct', result_asins, execution_time ) return recommendations, metrics def get_available_items(self): """Retorna lista de items disponibles para recomendación""" return list(self.item_encoder.keys()) # ==================== FUNCIONALIDAD 3: RECOMENDACIÓN BASADA EN CLIENTE (3 MÉTODOS) ==================== class ClientBasedRecommender: """Sistema de recomendación basado en productos seleccionados por un cliente""" def __init__(self, df_products, embeddings, ratings_dict): self.df_products = df_products self.embeddings = embeddings self.ratings_dict = ratings_dict self.setup_methods() def setup_methods(self): """Configura mapeo ASIN -> índice posicional""" self.asin_to_idx = {} parent_asins = self.df_products["parent_asin"].values for idx, asin in enumerate(parent_asins): if pd.notna(asin): self.asin_to_idx[asin] = idx self.prepare_content_features() # Verificación crítica assert len(self.embeddings) == len(self.df_products), \ f"ERROR: embeddings ({len(self.embeddings)}) y dataframe ({len(self.df_products)}) NO coinciden." def prepare_content_features(self): """Prepara características de contenido para recomendaciones""" # Extraer categorías principales categories = self.df_products.get('main_category', pd.Series(['Unknown'] * len(self.df_products))) self.unique_categories = list(set(categories.fillna('Unknown'))) # Crear matriz de características categóricas self.category_features = np.zeros((len(self.df_products), len(self.unique_categories))) for idx, category in enumerate(categories.fillna('Unknown')): if category in self.unique_categories: cat_idx = self.unique_categories.index(category) self.category_features[idx, cat_idx] = 1 def recommend_method_1_profile_similarity(self, selected_asins, n_recommendations=5): """Método 1: Perfil de usuario basado en similitud de embeddings""" start_time = time.time() if not selected_asins: return [], {'method': 'Profile_Similarity', 'execution_time': 0} # Obtener embeddings de productos seleccionados selected_embeddings = [] valid_asins = [] for asin in selected_asins: if asin in self.asin_to_idx: idx = self.asin_to_idx[asin] selected_embeddings.append(self.embeddings[idx]) valid_asins.append(asin) if not selected_embeddings: return [], {'method': 'Profile_Similarity', 'execution_time': 0} # Crear perfil de usuario como promedio de embeddings user_profile = np.mean(selected_embeddings, axis=0) # Calcular similitudes con todos los productos similarities = cosine_similarity([user_profile], self.embeddings).flatten() # Excluir productos ya seleccionados excluded_indices = [self.asin_to_idx[asin] for asin in valid_asins if asin in self.asin_to_idx] for idx in excluded_indices: similarities[idx] = -1 # Obtener top recomendaciones top_indices = np.argsort(similarities)[::-1][:n_recommendations] recommendations = [] for idx in top_indices: if similarities[idx] <= 0: continue row = self.df_products.iloc[idx] asin = row.get('parent_asin') if asin: recommendations.append({ 'asin': asin, 'similarity_score': similarities[idx], 'method': 'Profile_Similarity' }) execution_time = time.time() - start_time # Evaluar con métricas result_asins = [r['asin'] for r in recommendations] metrics = metrics_evaluator.evaluate_recommendations( 'client_profile', result_asins, execution_time ) return recommendations, metrics def recommend_method_2_weighted_categories(self, selected_asins, n_recommendations=5): """Método 2: Recomendación basada en categorías ponderadas""" start_time = time.time() if not selected_asins: return [], {'method': 'Weighted_Categories', 'execution_time': 0} # Contar categorías en productos seleccionados category_weights = defaultdict(float) valid_selections = 0 for asin in selected_asins: if asin in self.asin_to_idx: idx = self.asin_to_idx[asin] row = self.df_products.iloc[idx] category = row.get('main_category', 'Unknown') # Ponderar por rating del producto rating = self.ratings_dict.get(asin, 3.0) category_weights[category] += rating / 5.0 # Normalizar rating valid_selections += 1 if not category_weights: return [], {'method': 'Weighted_Categories', 'execution_time': 0} # Normalizar pesos total_weight = sum(category_weights.values()) for category in category_weights: category_weights[category] /= total_weight # Calcular scores para todos los productos product_scores = [] excluded_asins = set(selected_asins) for idx, row in self.df_products.iterrows(): asin = row.get('parent_asin') if not asin or asin in excluded_asins: continue category = row.get('main_category', 'Unknown') category_score = category_weights.get(category, 0.0) # Combinar con rating del producto product_rating = self.ratings_dict.get(asin, 0.0) final_score = category_score * 0.7 + (product_rating / 5.0) * 0.3 product_scores.append({ 'asin': asin, 'similarity_score': final_score, 'method': 'Weighted_Categories' }) # Ordenar por score y tomar top N product_scores.sort(key=lambda x: x['similarity_score'], reverse=True) recommendations = product_scores[:n_recommendations] execution_time = time.time() - start_time # Evaluar con métricas result_asins = [r['asin'] for r in recommendations] metrics = metrics_evaluator.evaluate_recommendations( 'client_categories', result_asins, execution_time ) return recommendations, metrics def recommend_method_3_hybrid_approach(self, selected_asins, n_recommendations=5): """Método 3: Enfoque híbrido combinando embeddings, categorías y ratings""" start_time = time.time() if not selected_asins: return [], {'method': 'Hybrid_Approach', 'execution_time': 0} # Paso 1: Crear perfil de embeddings selected_embeddings = [] selected_categories = [] selected_ratings = [] valid_asins = [] for asin in selected_asins: if asin in self.asin_to_idx: idx = self.asin_to_idx[asin] row = self.df_products.iloc[idx] selected_embeddings.append(self.embeddings[idx]) selected_categories.append(row.get('main_category', 'Unknown')) selected_ratings.append(self.ratings_dict.get(asin, 3.0)) valid_asins.append(asin) if not selected_embeddings: return [], {'method': 'Hybrid_Approach', 'execution_time': 0} # Crear perfil promedio ponderado por rating weights = np.array(selected_ratings) / 5.0 # Normalizar ratings weights = weights / np.sum(weights) # Normalizar pesos user_profile = np.average(selected_embeddings, axis=0, weights=weights) # Paso 2: Calcular preferencias de categoría category_preferences = Counter(selected_categories) total_selections = len(selected_categories) # Paso 3: Evaluar todos los productos candidatos candidate_scores = [] excluded_asins = set(selected_asins) for idx, row in self.df_products.iterrows(): asin = row.get('parent_asin') if not asin or asin in excluded_asins: continue # Score de similitud de embedding embedding_similarity = cosine_similarity([user_profile], [self.embeddings[idx]])[0][0] # Score de categoría category = row.get('main_category', 'Unknown') category_score = category_preferences.get(category, 0) / total_selections # Score de rating product_rating = self.ratings_dict.get(asin, 0.0) rating_score = product_rating / 5.0 # Combinación ponderada hybrid_score = ( embedding_similarity * 0.5 + category_score * 0.3 + rating_score * 0.2 ) candidate_scores.append({ 'asin': asin, 'similarity_score': hybrid_score, 'method': 'Hybrid_Approach', 'embedding_sim': embedding_similarity, 'category_score': category_score, 'rating_score': rating_score }) # Ordenar y tomar top N candidate_scores.sort(key=lambda x: x['similarity_score'], reverse=True) recommendations = candidate_scores[:n_recommendations] execution_time = time.time() - start_time # Evaluar con métricas result_asins = [r['asin'] for r in recommendations] metrics = metrics_evaluator.evaluate_recommendations( 'client_hybrid', result_asins, execution_time ) return recommendations, metrics # ==================== FUNCIONES DE UTILIDAD ==================== def clean_description(description): """Limpia la descripción eliminando corchetes y su contenido""" if not description or description == "": return "Sin descripción" if description.strip().startswith('[') and description.strip().endswith(']'): cleaned = description.strip()[1:-1].strip() else: cleaned = re.sub(r'\[.*?\]', '', description) cleaned = re.sub(r'\s+', ' ', cleaned).strip() return cleaned if cleaned else "Sin descripción" def get_best_image_url(row): """Extrae la mejor URL de imagen disponible""" image_columns = ['image_urls_best', 'image_urls_large', 'image_urls_all'] for col in image_columns: if col in row: try: images = json.loads(row[col]) if isinstance(row[col], str) else row[col] if isinstance(images, list) and images: for img_url in images: if img_url and isinstance(img_url, str) and img_url.startswith("http"): return img_url except (json.JSONDecodeError, TypeError, ValueError): continue return "https://via.placeholder.com/300x300.png?text=No+Image" def get_product_rating(asin): """Obtiene el rating de un producto desde el diccionario de ratings""" return ratings_dict.get(asin, 0.0) def get_product_info_by_asin(asin): """Obtiene información de un producto por su ASIN""" product_row = df_similars[df_similars['parent_asin'] == asin] if len(product_row) == 0: return None row = product_row.iloc[0] return { 'asin': asin, 'title': row.get('title', 'Sin título'), 'description': clean_description(row.get('description', '')), 'rating': get_product_rating(asin), 'image_url': get_best_image_url(row), 'category': row.get('main_category', 'Unknown') } # ==================== INICIALIZACIÓN DE SISTEMAS ==================== # Inicializar sistema de búsqueda por descripción description_searcher = DescriptionSearcher(df_similars, description_embeddings, model) # Inicializar sistema colaborativo solo si hay ratings detallados if HAS_DETAILED_RATINGS: print("Inicializando sistema de recomendación colaborativo...") collaborative_recommender = CollaborativeRecommender(df_ratings_detailed) else: print("Sistema colaborativo no disponible (requiere ratings detallados)") collaborative_recommender = None # Inicializar sistema basado en cliente client_recommender = ClientBasedRecommender(df_similars, description_embeddings, ratings_dict) # ==================== FUNCIONES DE INTERFAZ MEJORADAS ==================== def search_products_enhanced(descripcion_input, method_choice, max_images_per_product=2, target_products=5): """Búsqueda mejorada con selección de método""" if not descripcion_input.strip(): return [("https://via.placeholder.com/300.png?text=Vacío", "Por favor escribe algo para buscar...")] # Seleccionar método de búsqueda if method_choice == "KNN + Embeddings": results, metrics = description_searcher.search_method_1_knn(descripcion_input, target_products) elif method_choice == "TF-IDF + Cosine": results, metrics = description_searcher.search_method_2_tfidf(descripcion_input, target_products) elif method_choice == "Clustering + Embeddings": results, metrics = description_searcher.search_method_3_cluster(descripcion_input, target_products) else: # Comparar todos los métodos results_knn, metrics_knn = description_searcher.search_method_1_knn(descripcion_input, 2) results_tfidf, metrics_tfidf = description_searcher.search_method_2_tfidf(descripcion_input, 2) results_cluster, metrics_cluster = description_searcher.search_method_3_cluster(descripcion_input, 2) # Combinar resultados all_results = results_knn + results_tfidf + results_cluster results = sorted(all_results, key=lambda x: x['similarity_score'], reverse=True)[:target_products] metrics = { 'method': 'All_Methods_Combined', 'knn_time': metrics_knn.get('execution_time', 0), 'tfidf_time': metrics_tfidf.get('execution_time', 0), 'cluster_time': metrics_cluster.get('execution_time', 0) } # Convertir resultados a formato de galería gallery_results = [] for result in results: product_info = get_product_info_by_asin(result['asin']) if product_info: texto = f"🔍 Método: {result['method']}\n" texto += f"📦 {product_info['title']}\n" texto += f"⭐ Rating: {product_info['rating']:.2f}\n" texto += f"🎯 Similitud: {result['similarity_score']:.3f}\n" texto += f"📂 Categoría: {product_info['category']}\n\n" texto += f"📝 {product_info['description'][:200]}{'...' if len(product_info['description']) > 200 else ''}" gallery_results.append((product_info['image_url'], texto)) return gallery_results def get_collaborative_recommendations_enhanced(selected_product_asin, method_choice): """Recomendaciones colaborativas mejoradas con selección de método""" if not collaborative_recommender: return [("https://via.placeholder.com/300.png?text=No+Disponible", "Sistema colaborativo no disponible")] if not selected_product_asin: return [("https://via.placeholder.com/300.png?text=Vacío", "Por favor selecciona un producto...")] # Seleccionar método colaborativo if method_choice == "SVD": recommendations, metrics = collaborative_recommender.recommend_method_1_svd(selected_product_asin) elif method_choice == "NMF": recommendations, metrics = collaborative_recommender.recommend_method_2_nmf(selected_product_asin) elif method_choice == "Direct Similarity": recommendations, metrics = collaborative_recommender.recommend_method_3_direct(selected_product_asin) else: # Comparar todos los métodos rec_svd, met_svd = collaborative_recommender.recommend_method_1_svd(selected_product_asin, 2) rec_nmf, met_nmf = collaborative_recommender.recommend_method_2_nmf(selected_product_asin, 2) rec_direct, met_direct = collaborative_recommender.recommend_method_3_direct(selected_product_asin, 1) recommendations = rec_svd + rec_nmf + rec_direct metrics = {'method': 'All_Collaborative_Methods'} if not recommendations: return [("https://via.placeholder.com/300.png?text=Sin+Recomendaciones", "No se encontraron recomendaciones para este producto.")] # Convertir a formato de galería gallery_results = [] for rec in recommendations: product_info = get_product_info_by_asin(rec['asin']) if product_info: texto = f"🤝 Método: {rec['method']}\n" texto += f"📦 {product_info['title']}\n" texto += f"⭐ Rating: {product_info['rating']:.2f}\n" texto += f"🎯 Similitud: {rec['similarity_score']:.3f}\n" texto += f"📂 Categoría: {product_info['category']}\n\n" texto += f"📝 {product_info['description'][:200]}{'...' if len(product_info['description']) > 200 else ''}" gallery_results.append((product_info['image_url'], texto)) return gallery_results def get_client_recommendations(selected_asins_text, method_choice, n_recommendations=5): """Recomendaciones basadas en cliente con selección de método""" if not selected_asins_text.strip(): return [("https://via.placeholder.com/300.png?text=Vacío", "Por favor ingresa ASINs de productos...")] # Parsear ASINs (separados por comas, espacios o nuevas líneas) selected_asins = [] for asin in re.split(r'[,\s\n]+', selected_asins_text.strip()): asin = asin.strip() if asin: selected_asins.append(asin) if not selected_asins: return [("https://via.placeholder.com/300.png?text=Error", "No se pudieron parsear los ASINs")] # Seleccionar método de recomendación basada en cliente if method_choice == "Profile Similarity": recommendations, metrics = client_recommender.recommend_method_1_profile_similarity(selected_asins, n_recommendations) elif method_choice == "Weighted Categories": recommendations, metrics = client_recommender.recommend_method_2_weighted_categories(selected_asins, n_recommendations) elif method_choice == "Hybrid Approach": recommendations, metrics = client_recommender.recommend_method_3_hybrid_approach(selected_asins, n_recommendations) else: # Comparar todos los métodos rec_profile, met_profile = client_recommender.recommend_method_1_profile_similarity(selected_asins, 2) rec_categories, met_categories = client_recommender.recommend_method_2_weighted_categories(selected_asins, 2) rec_hybrid, met_hybrid = client_recommender.recommend_method_3_hybrid_approach(selected_asins, 1) recommendations = rec_profile + rec_categories + rec_hybrid metrics = {'method': 'All_Client_Methods'} if not recommendations: return [("https://via.placeholder.com/300.png?text=Sin+Recomendaciones", "No se encontraron recomendaciones para los productos seleccionados.")] # Convertir a formato de galería gallery_results = [] for rec in recommendations: product_info = get_product_info_by_asin(rec['asin']) if product_info: texto = f"👤 Método: {rec['method']}\n" texto += f"📦 {product_info['title']}\n" texto += f"⭐ Rating: {product_info['rating']:.2f}\n" texto += f"🎯 Score: {rec['similarity_score']:.3f}\n" texto += f"📂 Categoría: {product_info['category']}\n\n" # Información adicional para método híbrido if 'embedding_sim' in rec: texto += f"🔗 Sim. Embedding: {rec['embedding_sim']:.3f}\n" texto += f"📂 Score Categoría: {rec['category_score']:.3f}\n" texto += f"⭐ Score Rating: {rec['rating_score']:.3f}\n\n" texto += f"📝 {product_info['description'][:150]}{'...' if len(product_info['description']) > 150 else ''}" gallery_results.append((product_info['image_url'], texto)) return gallery_results def get_product_options(): """Obtiene lista de productos disponibles para el dropdown""" if not collaborative_recommender: return [("Sistema no disponible", "")] available_asins = collaborative_recommender.get_available_items() options = [] for asin in available_asins[:100]: # Limitar para performance product_info = get_product_info_by_asin(asin) if product_info and product_info['rating'] > 0: label = f"{product_info['title'][:50]}... (Rating: {product_info['rating']:.1f})" options.append((label, asin)) return options def get_metrics_report(): """Genera reporte de métricas para mostrar en la interfaz""" return metrics_evaluator.get_comparison_report() # ==================== INTERFAZ GRADIO MEJORADA ==================== def create_enhanced_interface(): """Crea la interfaz mejorada con todas las funcionalidades y métricas""" with gr.Blocks(title="🚀 Advanced Product Recommendaation System", theme=gr.themes.Soft()) as demo: gr.Markdown(""" # 🚀 Advanced Product Recommendaation System **Funcionalidades disponibles:** - 🔍 **Búsqueda por Descripción** (3 métodos: KNN+Embeddings, TF-IDF+Cosine, Clustering+Embeddings) - 🤝 **Recomendación Colaborativa** (3 métodos: SVD, NMF, Direct Similarity) - 👤 **Recomendación Basada en Cliente** (3 métodos: Profile Similarity, Weighted Categories, Hybrid Approach) - 📊 **Métricas y Comparación** en tiempo real """) with gr.Tabs(): # TAB 1: Búsqueda por descripción mejorada with gr.TabItem("🔍 Búsqueda por Descripción"): gr.Markdown("### Describe el producto que buscas en inglés y selecciona el método de búsqueda") with gr.Row(): with gr.Column(scale=1): descripcion_input = gr.Textbox( label="Describe your ideal product", placeholder="exp: Handmade shungite bead bracelet, Silver necklace, etc." ) search_method = gr.Dropdown( choices=["KNN + Embeddings", "TF-IDF + Cosine", "Clustering + Embeddings", "Comparar Todos"], value="KNN + Embeddings", label="Método de búsqueda" ) max_images = gr.Slider( minimum=1, maximum=3, value=2, step=1, label="Máximo de imágenes por producto" ) num_products = gr.Slider( minimum=1, maximum=10, value=5, step=1, label="Número de productos a mostrar" ) search_btn = gr.Button("🔍 Buscar Productos", variant="primary", size="lg") with gr.Column(scale=2): search_gallery = gr.Gallery( label="Productos Encontrados", columns=3, rows=2, height="auto" ) # TAB 2: Recomendaciones colaborativas mejoradas if collaborative_recommender: with gr.TabItem("🤝 Recomendaciones Colaborativas"): gr.Markdown("### Selecciona un producto base y el método de recomendación colaborativa") with gr.Row(): with gr.Column(scale=1): product_dropdown = gr.Dropdown( choices=get_product_options(), label="Selecciona un producto base", value=None ) collab_method = gr.Dropdown( choices=["SVD", "NMF", "Direct Similarity", "Comparar Todos"], value="SVD", label="Método colaborativo" ) recommend_btn = gr.Button("🤝 Obtener Recomendaciones", variant="primary", size="lg") refresh_products_btn = gr.Button("🔄 Actualizar Lista") with gr.Column(scale=2): recommendations_gallery = gr.Gallery( label="Recomendaciones Colaborativas", columns=2, rows=2, height="auto" ) # TAB 3: Recomendaciones basadas en cliente (NUEVA FUNCIONALIDAD) with gr.TabItem("👤 Recomendaciones Basadas en Cliente"): gr.Markdown(""" ### Ingresa los ASINs de productos que un cliente ha seleccionado **Formato:** Separa los ASINs con comas, espacios o nuevas líneas **Ejemplo 1:** B07NTK7T5P, B0751M85FV, B01HYNE114, B0BKBJT5MM. **Ejemplo 2:** B01BAN3CBE, B0754TWHPT, B079KM6HDM, B097B8WH61. **Ejemplo 3:** B0B8WK62Z3, B01BYCH44W, B0BGNQ3CLH, B084L4PF4M. """) with gr.Row(): with gr.Column(scale=1): client_asins_input = gr.Textbox( label="ASINs de productos seleccionados por el cliente", placeholder="Insert here the product´s ID´s to get other products you might enjoy!", lines=3 ) client_method = gr.Dropdown( choices=["Profile Similarity", "Weighted Categories", "Hybrid Approach", "Comparar Todos"], value="Hybrid Approach", label="Método de recomendación" ) client_num_recs = gr.Slider( minimum=1, maximum=10, value=5, step=1, label="Número de recomendaciones" ) client_recommend_btn = gr.Button("👤 Generar Recomendaciones", variant="primary", size="lg") with gr.Accordion("ℹ️ Información de Métodos", open=False): gr.Markdown(""" **Profile Similarity:** Crea un perfil promedio basado en los embeddings de los productos seleccionados **Weighted Categories:** Recomienda basándose en las categorías más frecuentes, ponderadas por rating **Hybrid Approach:** Combina embeddings, categorías y ratings con pesos optimizados """) with gr.Column(scale=2): client_gallery = gr.Gallery( label="Recomendaciones para el Cliente", columns=3, rows=2, height="auto" ) # TAB 4: Métricas y comparación with gr.TabItem("📊 Métricas y Comparación"): gr.Markdown("### Análisis de rendimiento y comparación de métodos") with gr.Row(): with gr.Column(): metrics_btn = gr.Button("📊 Actualizar Métricas", variant="secondary") clear_metrics_btn = gr.Button("🗑️ Limpiar Historial") metrics_output = gr.Markdown("Ejecuta algunas recomendaciones para ver las métricas...") # Estadísticas del sistema with gr.Accordion("📈 Estadísticas del Sistema", open=False): collab_stats = "" if collaborative_recommender: collab_stats = f""" - 🤝 Productos disponibles para recomendación colaborativa: {len(collaborative_recommender.get_available_items()):,} - 🧮 Dimensiones de matriz SVD: {collaborative_recommender.item_similarity_matrix.shape} """ stats_text = f""" **Estadísticas del Sistema Completo:** - 📊 Total de productos: {len(df_similars):,} - ⭐ Productos con ratings: {len(ratings_dict):,} - 🔍 Embeddings precalculados: {len(description_embeddings):,} - ✅ Consistencia verificada: {len(description_embeddings) == len(df_similars)} - 🎯 Métodos de búsqueda: 3 implementados - 🤝 Métodos colaborativos: {"3 implementados" if collaborative_recommender else "No disponible"} - 👤 Métodos basados en cliente: 3 implementados {collab_stats} """ gr.Markdown(stats_text) # ==================== EVENTOS ==================== # Búsqueda por descripción search_btn.click( fn=search_products_enhanced, inputs=[descripcion_input, search_method, max_images, num_products], outputs=search_gallery ) # Recomendaciones colaborativas (solo si está disponible) if collaborative_recommender: recommend_btn.click( fn=get_collaborative_recommendations_enhanced, inputs=[product_dropdown, collab_method], outputs=recommendations_gallery ) refresh_products_btn.click( fn=lambda: gr.Dropdown(choices=get_product_options()), outputs=product_dropdown ) # Recomendaciones basadas en cliente client_recommend_btn.click( fn=get_client_recommendations, inputs=[client_asins_input, client_method, client_num_recs], outputs=client_gallery ) # Métricas metrics_btn.click( fn=get_metrics_report, outputs=metrics_output ) def clear_metrics(): global metrics_evaluator metrics_evaluator = RecommendationMetrics() return "Historial de métricas limpiado." clear_metrics_btn.click( fn=clear_metrics, outputs=metrics_output ) return demo # ==================== LANZAMIENTO ==================== if __name__ == "__main__": print("🚀 Iniciando sistema avanzado de recomendación...") # Verificar configuración print(f"✅ DataFrame: {len(df_similars):,} productos") print(f"✅ Embeddings: {description_embeddings.shape}") print(f"✅ Consistencia: {len(description_embeddings) == len(df_similars)}") print(f"✅ Búsqueda por descripción: 3 métodos disponibles") if collaborative_recommender: print(f"✅ Sistema colaborativo: 3 métodos con {len(collaborative_recommender.get_available_items()):,} productos") else: print("⚠️ Sistema colaborativo no disponible") print(f"✅ Sistema basado en cliente: 3 métodos disponibles") print(f"✅ Sistema de métricas: Inicializado") # Crear y lanzar interfaz demo = create_enhanced_interface() demo.launch( share=False, debug=False, show_error=True, server_name="0.0.0.0", server_port=7860 )