feat: Updated version management and retroalimentacion

app.py

@@ -90,7 +90,7 @@ nombres_proveedores['codigo'] = nombres_proveedores['codigo'].astype(str)
 euros_proveedor['CLIENTE'] = euros_proveedor['CLIENTE'].astype(str)
 customer_clusters['cliente_id'] = customer_clusters['cliente_id'].astype(str)  # Ensure customer IDs are strings
 fieles_df = pd.read_csv("clientes_relevantes.csv")
-cestas = pd.read_csv("cestas.csv")
+cestas = pd.read_csv("cestas_su.csv")
 productos = pd.read_csv("productos.csv")
 df_agg_2024['cliente_id'] = df_agg_2024['cliente_id'].astype(str)
 marca_id_mapping = load('marca_id_mapping.joblib')
@@ -868,7 +868,7 @@ elif page == "🕵️ Análisis de Cliente":
 # Customer Recommendations Page
 elif page == "💡 Recomendación de Artículos":
     # Carga de CSV necesarios cestas y productos
-    cestas = pd.read_csv('cestas.csv') 
+    cestas = pd.read_csv('cestas_su.csv') 
     productos = pd.read_csv('productos.csv')
     
     # Estilo principal de la página

utils.py

@@ -1,20 +1,66 @@
 import pandas as pd
 import numpy as np
 import warnings
+import glob
+import os
+import re
 warnings.filterwarnings('ignore')
-from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
 from sklearn.metrics.pairwise import cosine_similarity
 from joblib import dump, load
 from sklearn.preprocessing import normalize
 
+def get_latest_version(base_filename):
+    """
+    Obtiene la última versión del archivo guardado.
+    Args:
+        base_filename (str): Nombre base del archivo (sin versión)
+    Returns:
+        str: Nombre del archivo con la versión más reciente
+    """
+    # Buscar todos los archivos que coincidan con el patrón
+    pattern = f"{base_filename}_*.joblib"
+    matching_files = glob.glob(pattern)
+    
+    if not matching_files:
+        return f"{base_filename}_0001.joblib"
+    
+    # Extraer los números de versión y encontrar el máximo
+    versions = []
+    for file in matching_files:
+        match = re.search(r'_(\d{4})\.joblib$', file)
+        if match:
+            versions.append(int(match.group(1)))
+    
+    if versions:
+        latest_version = max(versions)
+        return f"{base_filename}_{latest_version:04d}.joblib"
+    
+    return f"{base_filename}_0001.joblib"
 
+def get_next_version(base_filename):
+    """
+    Genera el nombre del archivo para la siguiente versión.
+    Args:
+        base_filename (str): Nombre base del archivo (sin versión)
+    Returns:
+        str: Nombre del archivo con la siguiente versión
+    """
+    latest_file = get_latest_version(base_filename)
+    match = re.search(r'_(\d{4})\.joblib$', latest_file)
+    if match:
+        current_version = int(match.group(1))
+        next_version = current_version + 1
+    else:
+        next_version = 1
+    
+    return f"{base_filename}_{next_version:04d}.joblib"
 
-
-def recomienda_tf(new_basket,cestas,productos): 
+def recomienda_tf(new_basket, cestas): 
     # Cargar la matriz TF y el modelo
-    tf_matrix = load('tf_matrix.joblib')
-                      
-    count = load('count_vectorizer.joblib')
+    tf_matrix = load(get_latest_version('tf_matrix'))
+    count = load(get_latest_version('count_vectorizer'))
+                    
     # Convertir la nueva cesta en formato TF (Term Frequency)
     new_basket_str = ' '.join(new_basket)
     new_basket_vector = count.transform([new_basket_str])
@@ -60,4 +106,85 @@ def recomienda_tf(new_basket,cestas,productos):
             })
     recommendations_df = pd.DataFrame(recommendations_data)
     
-    return recommendations_df
+    return recommendations_df
+
+def retroalimentacion(cestas, cesta_nueva):
+    # Pasamos de lista a cadena de texto
+    cesta_unida = ' '.join(cesta_nueva)
+    # Añadimos la cesta nueva al histórico de cestas. Primero comprobamos si la cesta nueva ya está
+    if not cestas['Cestas'].isin([cesta_unida]).any():
+        # Añadir la nueva cesta si no existe
+        cestas.loc[len(cestas)] = cesta_unida
+        print("Cesta añadida.")
+        # Reescribimos la nueva cesta
+        cestas.to_csv('cesta_su.csv')
+    else:
+        print("La cesta ya existe en el DataFrame.")
+    
+    # Vectorizamos de nuevo el df de cestas
+    count_vectorizer = CountVectorizer()
+    count_vectorizer.fit(cestas['Cestas'])
+    count_matrix = count_vectorizer.transform(cestas['Cestas'])
+    tf_matrix = normalize(count_matrix, norm='l1')
+
+    # Guardar con nueva versión
+    count_vectorizer_file = get_next_version('count_vectorizer')
+    tf_matrix_file = get_next_version('tf_matrix')
+    
+    dump(count_vectorizer, count_vectorizer_file)
+    dump(tf_matrix, tf_matrix_file)
+    
+
+    return None
+
+# def recomienda_tf(new_basket,cestas,productos): 
+#     # Cargar la matriz TF y el modelo
+#     tf_matrix = load('tf_matrix.joblib')
+                      
+#     count = load('count_vectorizer.joblib')
+#     # Convertir la nueva cesta en formato TF (Term Frequency)
+#     new_basket_str = ' '.join(new_basket)
+#     new_basket_vector = count.transform([new_basket_str])
+#     new_basket_tf = normalize(new_basket_vector, norm='l1')  # Normalizamos la matriz count de la cesta actual
+#     # Comparar la nueva cesta con las anteriores
+#     similarities = cosine_similarity(new_basket_tf, tf_matrix)
+#     # Obtener los índices de las cestas más similares
+#     similar_indices = similarities.argsort()[0][-4:]  # Las 4 más similares
+#     # Crear un diccionario para contar las recomendaciones
+#     recommendations_count = {}
+#     total_similarity = 0
+#     # Recomendar productos de cestas similares
+#     for idx in similar_indices:
+#         sim_score = similarities[0][idx]
+#         total_similarity += sim_score  # Suma de las similitudes
+#         products = cestas.iloc[idx]['Cestas'].split()
+#         # Usar un conjunto para evitar contar productos múltiples veces en la misma cesta
+#         unique_products = set(products)  # Usar un conjunto para obtener productos únicos
+#         # Con esto evitamos que la importancia crezca por las unidades
+#         for product in unique_products:
+#             if product.strip() not in new_basket:  # Evitar recomendar lo que ya está en la cesta
+#                 recommendations_count[product.strip()] = recommendations_count.get(product.strip(), 0) + sim_score
+#                 # Almacena el conteo de la relevancia de cada producto basado en cuántas veces aparece en las cestas similares, ponderado por la similitud de cada cesta.
+#     # Calcular la probabilidad relativa de cada producto recomendado
+#     recommendations_with_prob = []
+#     if total_similarity > 0:  # Verificar que total_similarity no sea cero
+#         recommendations_with_prob = [(product, score / total_similarity) for product, score in recommendations_count.items()]
+#     else:
+#         print("No se encontraron similitudes suficientes para calcular probabilidades.")
+     
+#     recommendations_with_prob.sort(key=lambda x: x[1], reverse=True)  # Ordenar por puntuación
+#     # Crear un nuevo DataFrame para almacenar las recomendaciones
+#     recommendations_data = []
+    
+#     for product, score in recommendations_with_prob:
+#         # Buscar la descripción en el DataFrame de productos
+#         description = productos.loc[productos['ARTICULO'] == product, 'DESCRIPCION']
+#         if not description.empty:
+#             recommendations_data.append({
+#                 'ARTICULO': product,
+#                 'DESCRIPCION': description.values[0],  # Obtener el primer valor encontrado
+#                 'RELEVANCIA': score
+#             })
+#     recommendations_df = pd.DataFrame(recommendations_data)
+    
+#     return recommendations_df