Upload 5 files

Recomendation.py

@@ -0,0 +1,100 @@
+from sklearn.metrics.pairwise import cosine_similarity
+import pandas as pd
+import numpy as np
+from vectorization import spotify_data
+import json
+import gradio as gr
+from gradio.components import Textbox
+from ast import literal_eval
+spotify_data_processed = pd.read_csv('C:\\Users\\34640\\Desktop\\Saturdays.ai\\spotify_dset\\dataset_modificado.csv')
+
+def convert_string_to_array(str_vector):
+    # Si str_vector ya es un array de NumPy, devolverlo directamente
+    if isinstance(str_vector, np.ndarray):
+        return str_vector
+
+    try:
+        cleaned_str = str_vector.replace('[', '').replace(']', '').replace('\n', ' ').replace('\r', '').strip()
+        vector_elements = [float(item) for item in cleaned_str.split()]
+        return np.array(vector_elements)
+    except ValueError as e:
+        print("Error:", e)
+        return np.zeros((100,))
+
+
+spotify_data_processed['song_vector'] = spotify_data_processed['song_vector'].apply(convert_string_to_array)
+
+
+# Aplicar la función a las primeras filas para ver los resultados
+sample_data = spotify_data_processed['song_vector'].head()
+converted_vectors = sample_data.apply(convert_string_to_array)
+print(converted_vectors)
+
+
+
+def recommend_song(song_name, artist_name, spotify_data_processed, top_n=4):
+    # Filtrar para encontrar la canción específica
+    specific_song = spotify_data_processed[(spotify_data_processed['song'] == song_name)
+                                            & (spotify_data_processed['artist'] == artist_name)]
+
+    # Verificar si la canción existe en el dataset
+    if specific_song.empty:
+        return pd.DataFrame({"Error": ["Canción no encontrada en la base de datos."]})
+
+
+    # Obtener el vector de la canción específica
+    song_vec = specific_song['song_vector'].iloc[0]
+
+    # Asegurarte de que song_vec sea un array de NumPy
+    if isinstance(song_vec, str):
+        song_vec = convert_string_to_array(song_vec)
+
+    all_song_vectors = np.array(spotify_data_processed['song_vector'].tolist())
+
+    # Calcular similitudes
+    similarities = cosine_similarity([song_vec], all_song_vectors)[0]
+
+    # Obtener los índices de las canciones más similares
+    top_indices = np.argsort(similarities)[::-1][1:top_n+1]
+
+    # Devolver los nombres y artistas de las canciones más similares
+    recommended_songs = spotify_data_processed.iloc[top_indices][['song', 'artist']]
+    return recommended_songs
+
+
+
+
+
+def recommend_song_interface(song_name, artist_name):
+    recommendations_df = recommend_song(song_name, artist_name, spotify_data_processed)
+    
+    if isinstance(recommendations_df, pd.DataFrame):
+        # Convierte el DataFrame en una lista de listas y luego a un formato de texto plano para la salida
+        recommendations_list = recommendations_df.values.tolist()
+        return ["{} by {}".format(song, artist) for song, artist in recommendations_list]
+    else:
+        # Si no es un DataFrame, devolver el mensaje de error
+        return recommendations_df
+
+# Crear la interfaz con Gradio
+iface = gr.Interface(
+    fn=recommend_song_interface,
+    inputs=[
+        gr.Textbox(placeholder="Ingrese el título de la canción", label="Título de la Canción"),
+        gr.Textbox(placeholder="Ingrese el nombre del artista", label="Nombre del Artista")
+    ],
+    outputs=[gr.Text(label="Recomendación 1"),
+             gr.Text(label="Recomendación 2"),
+             gr.Text(label="Recomendación 3"),
+             gr.Text(label="Recomendación 4")],
+    title="Recomendador de Canciones",
+    description="Ingrese el título de una canción y el nombre del artista para obtener recomendaciones.",
+    theme="dark",  # Comenta o elimina si el tema oscuro no está disponible
+    css="""
+        body {font-family: Arial, sans-serif;}
+        .input_text {background-color: #f0f0f0; border-radius: 5px;}
+        .output_text {border: 2px solid #f0f0f0; border-radius: 5px; padding: 10px;}
+        """
+)
+
+iface.launch()

data_processing.py

@@ -0,0 +1,46 @@
+import pandas as pd
+import numpy as np
+import sys
+import codecs
+#-------------------Load_data, function that loads the Spotify Dataset 1921-2020, 600k+-------------------------- 
+#-------------------Tracks and checks with an error check if the data has been loaded correctly.----------------
+
+def load_data (path):
+    try:
+        df = pd.read_csv(path)
+        return df
+    except FileNotFoundError:
+        print(f"The document is not found in the directory: {path}")
+        return None
+    except Exception as e:
+        print(f"An error occurred loading the file: {e}")
+        return None
+path = 'C:\\Users\\34640\\Desktop\\Saturdays.ai\\spotify_dset\\spotify_millsongdata.csv\\spotify_millsongdata.csv'
+spotify_data = load_data(path)
+
+spotify_data.columns = ['artist', 'song', 'link', 'text']
+
+
+
+if spotify_data is not None:
+    print("-----------Suscessfully loaded-------------")
+    
+
+   # print(spotify_data.isnull().sum())
+#-----------Fill up white space-----------#
+    for col in spotify_data.columns:
+        spotify_data[col] = spotify_data[col].fillna(spotify_data[col].mode()[0])
+
+#-----------Convert to lower case and delete special characters-----------#
+        spotify_data[col] = spotify_data[col].str.lower().str.replace('[^\w\s]', '', regex=True)
+
+
+#-----------Delete duplicates-----------#
+    spotify_data = spotify_data.drop_duplicates()
+
+    #print(spotify_data.isnull().sum())
+else:
+    print("No spotify data")
+
+
+    

tokenizer.py

@@ -0,0 +1,34 @@
+from data_processing import load_data, spotify_data, path
+import pandas 
+import nltk
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+import string
+
+#---------------------------Download the requirements NLTK--------------------------------
+
+#nltk.download('punkt')
+#nltk.download('stopwords')
+
+def clean_lyrics(lyrics):
+    # Tokenización
+    tokens = word_tokenize(lyrics)
+
+    # To lower case 
+    tokens = [word.lower() for word in tokens]
+
+    # Delete signs 
+    table = str.maketrans('', '', string.punctuation)
+    stripped_tokens = [word.translate(table) for word in tokens]
+
+    # Stop Words
+    stop_words = set(stopwords.words('english'))  
+    tokens_without_sw = [word for word in stripped_tokens if word not in stop_words]
+
+    return tokens_without_sw
+
+# Apply clean
+spotify_data['cleaned_text'] = spotify_data['text'].apply(clean_lyrics)
+spotify_data.to_csv('C:\\Users\\34640\\Desktop\\Saturdays.ai\\spotify_dset\\spotify_data_processed.csv', index=False)
+
+#print(spotify_data['cleaned_text'].head())

vectorial_representation.py

@@ -0,0 +1,20 @@
+import numpy as np
+from vectorization import model, spotify_data
+
+# Función para convertir una canción en un vector promedio de sus palabras
+def song_vector(tokens, model):
+    # Filtrar palabras que están en el modelo
+    tokens = [word for word in tokens if word in model.wv.key_to_index]
+
+    if len(tokens) == 0:
+        return np.zeros(model.vector_size)
+
+    # Calcular el promedio de los vectores de las palabras
+    song_vec = np.mean([model.wv[word] for word in tokens], axis=0)
+    return song_vec
+
+# Aplicar esta función a cada canción en tu dataset
+spotify_data['song_vector'] = spotify_data['cleaned_text'].apply(lambda x: song_vector(x, model))
+spotify_data.to_csv('C:\\Users\\34640\\Desktop\\Saturdays.ai\\spotify_dset\\dataset_modificado.csv', index=False)
+
+

vectorization.py

@@ -0,0 +1,15 @@
+from gensim.models import Word2Vec
+import pandas as pd
+
+
+spotify_data= pd.read_csv('C:\\Users\\34640\\Desktop\\Saturdays.ai\\spotify_dset\\spotify_data_processed.csv')
+
+
+
+
+# Asumiendo que spotify_data['cleaned_text'] contiene listas de palabras (tokens)
+spotify_data['cleaned_text'] = spotify_data['cleaned_text'].apply(eval)
+
+model = Word2Vec(sentences=spotify_data['cleaned_text'], vector_size=100, window=10, min_count=1, workers=5)
+# Guardar el modelo
+model.save("word2vec_model.model")