Añadida variable de entrada de la función recomienda_tf

utils.py

@@ -1,190 +1,190 @@
-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, 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): 
-    # Cargar la matriz TF y el modelo
-    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])
-    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
-
-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)
-    
+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, 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): 
+    # Cargar la matriz TF y el modelo
+    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])
+    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
+
+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