Update utils.py

utils.py

@@ -11,6 +11,9 @@ import re
 
 def get_next_version(file_prefix, folder='RecommendationFiles/'):
     """Find the latest version of a file and return the next version's filename."""
+    if not os.path.exists(folder):
+        os.makedirs(folder)  # Ensure the folder exists
+
     # Regular expression to match files like 'file_0001.joblib'
     pattern = re.compile(rf"{file_prefix}_(\d+)\.joblib")
     files = [f for f in os.listdir(folder) if pattern.match(f)]
@@ -19,16 +22,16 @@ def get_next_version(file_prefix, folder='RecommendationFiles/'):
     versions = [int(pattern.match(f).group(1)) for f in files]
     
     # Determine the next version number
-    if versions:
-        next_version = max(versions) + 1
-    else:
-        next_version = 1  # If no versions exist, start with 1
+    next_version = max(versions) + 1 if versions else 1
     
-    # Return the next version filename
-    return f"{file_prefix}_{next_version:04d}.joblib"
+    # Return the next version filename with the folder path
+    return os.path.join(folder, f"{file_prefix}_{next_version:04d}.joblib")
 
 def get_latest_version(file_prefix, folder='RecommendationFiles/'):
     """Find the latest version of a file to load."""
+    if not os.path.exists(folder):
+        raise FileNotFoundError(f"Folder '{folder}' does not exist")
+    
     # Regular expression to match files like 'file_0001.joblib'
     pattern = re.compile(rf"{file_prefix}_(\d+)\.joblib")
     files = [f for f in os.listdir(folder) if pattern.match(f)]
@@ -38,61 +41,68 @@ def get_latest_version(file_prefix, folder='RecommendationFiles/'):
     
     if versions:
         latest_version = max(versions)
-        return f"{file_prefix}_{latest_version:04d}.joblib"
+        return os.path.join(folder, f"{file_prefix}_{latest_version:04d}.joblib")
     else:
-        raise FileNotFoundError(f"No versions found for {file_prefix}")
+        raise FileNotFoundError(f"No versions found for {file_prefix} in folder '{folder}'")
 
 
 def recomienda_tf(new_basket, cestas, productos): 
 
+    # Get the latest versions of the matrix and vectorizer from the folder
     tf_matrix_file = get_latest_version('count_matrix')
     count_vectorizer_file = get_latest_version('count_vectorizer')
     
-    # Cargar la matriz TF y el modelo
+    # Load the matrix TF and the vectorizer
     tf_matrix = load(tf_matrix_file)
     count = load(count_vectorizer_file)
                     
-    # Convertir la nueva cesta en formato TF (Term Frequency)
+    # Convert the new basket into TF (Term Frequency) format
     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
+    new_basket_tf = normalize(new_basket_vector, norm='l1')  # Normalize the count matrix for the current basket
+
+    # Compare the new basket with previous ones
     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
+    
+    # Get the indices of the most similar baskets
+    similar_indices = similarities.argsort()[0][-4:]  # Top 4 most similar baskets
+    
+    # Create a dictionary to count recommendations
     recommendations_count = {}
     total_similarity = 0
-    # Recomendar productos de cestas similares
+    
+    # Recommend products from similar baskets
     for idx in similar_indices:
         sim_score = similarities[0][idx]
-        total_similarity += sim_score  # Suma de las similitudes
+        total_similarity += sim_score  # Sum of similarities
         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
+        
+        unique_products = set(products)  # Use a set to get unique products
+        
         for product in unique_products:
-            if product.strip() not in new_basket:  # Evitar recomendar lo que ya está en la cesta
+            if product.strip() not in new_basket:  # Avoid recommending items already in the basket
                 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
+    
+    # Calculate the relative probability of each recommended product
     recommendations_with_prob = []
-    if total_similarity > 0:  # Verificar que total_similarity no sea cero
+    if total_similarity > 0:
         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
+    # Sort recommendations by relevance score
+    recommendations_with_prob.sort(key=lambda x: x[1], reverse=True)
+    
+    # Create a new DataFrame to store recommendations
     recommendations_data = []
     
     for product, score in recommendations_with_prob:
-        # Buscar la descripción en el DataFrame de productos
+        # Search for the product description in the products DataFrame
         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
+                'DESCRIPCION': description.values[0],
                 'RELEVANCIA': score
             })
     recommendations_df = pd.DataFrame(recommendations_data)
@@ -100,30 +110,30 @@ def recomienda_tf(new_basket, cestas, productos):
     return recommendations_df.head(5)
 
 def retroalimentacion(cestas, cesta_nueva):
-    # Pasamos de lista a cadena de texto
+    # Convert basket from list to string
     cesta_unida = ' '.join(cesta_nueva)
-    # Añadimos la cesta nueva al histórico de cestas. Primero comprobamos si la cesta nueva ya está
+    
+    # Add the new basket to the historical baskets if it doesn't already exist
     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('cestas_final.csv')
+        
+        # Re-save the updated baskets DataFrame
+        cestas.to_csv('RecommendationFiles/cestas_final.csv', index=False)
     else:
         print("La cesta ya existe en el DataFrame.")
     
-    # Vectorizamos de nuevo el df de cestas
+    # Re-vectorize the basket DataFrame
     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
+    # Save new versions of the vectorizer and matrix
     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