Update app.py

app.py

@@ -2,26 +2,17 @@ import gradio as gr
 from sentence_transformers import SentenceTransformer, util
 import openai
 import os
-
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
-
 # Initialize paths and model identifiers for easy configuration and maintenance
-filename = "output_topic_details.txt"  # Path to the file storing song-specific details
+filename = "output_topic_details.txt"  # Path to the file storing song recommendation details
 retrieval_model_name = 'output/sentence-transformer-finetuned/'
-
 openai.api_key = os.environ["OPENAI_API_KEY"]
-
-system_message = "You are a song chatbot specialized in providing song recommendations based on mood catering to Gen Z taste in music."
-# Initial system message to set the behavior of the assistant
-messages = [{"role": "system", "content": system_message}]
-
 # Attempt to load the necessary models and provide feedback on success or failure
 try:
     retrieval_model = SentenceTransformer(retrieval_model_name)
     print("Models loaded successfully.")
 except Exception as e:
     print(f"Failed to load models: {e}")
-
 def load_and_preprocess_text(filename):
     """
     Load and preprocess text from a file, removing empty lines and stripping whitespace.
@@ -34,9 +25,7 @@ def load_and_preprocess_text(filename):
     except Exception as e:
         print(f"Failed to load or preprocess text: {e}")
         return []
-
 segments = load_and_preprocess_text(filename)
-
 def find_relevant_segment(user_query, segments):
     """
     Find the most relevant text segment for a user's query using cosine similarity among sentence embeddings.
@@ -45,121 +34,81 @@ def find_relevant_segment(user_query, segments):
     try:
         # Lowercase the query for better matching
         lower_query = user_query.lower()
-
         # Encode the query and the segments
         query_embedding = retrieval_model.encode(lower_query)
         segment_embeddings = retrieval_model.encode(segments)
-
         # Compute cosine similarities between the query and the segments
         similarities = util.pytorch_cos_sim(query_embedding, segment_embeddings)[0]
-
         # Find the index of the most similar segment
         best_idx = similarities.argmax()
-
         # Return the most relevant segment
         return segments[best_idx]
     except Exception as e:
         print(f"Error in finding relevant segment: {e}")
         return ""
-
 def generate_response(user_query, relevant_segment):
     """
-    Generate a response emphasizing the bot's capability in providing song recommendations.
+    Generate a response providing song recommendations based on mood.
     """
     try:
-        user_message = f"Here's the information on songs: {relevant_segment}"
-
-        # Append user's message to messages list
-        messages.append({"role": "user", "content": user_message})
-
-        # Use OpenAI's API to generate a response based on the user's query and system messages
+        system_message = "You are a music recommendation chatbot designed to suggest songs based on mood, catering to Gen Z's taste in music."
+        user_message = f"User query: {user_query}. Recommended songs: {relevant_segment}"
+        messages = [
+            {"role": "system", "content": system_message},
+            {"role": "user", "content": user_message}
+        ]
         response = openai.ChatCompletion.create(
             model="gpt-3.5-turbo",
             messages=messages,
             max_tokens=150,
-            temperature=0.2,
+            temperature=0.7,
             top_p=1,
             frequency_penalty=0,
             presence_penalty=0
         )
-
-        # Extract the response text
-        output_text = response['choices'][0]['message']['content'].strip()
-
-        # Append assistant's message to messages list for context
-        messages.append({"role": "assistant", "content": output_text})
-
-        return output_text
-
+        return response['choices'][0]['message']['content'].strip()
     except Exception as e:
         print(f"Error in generating response: {e}")
         return f"Error in generating response: {e}"
-
-def recommend_songs_based_on_mood(mood):
+def query_model(question):
     """
-    Recommend songs based on the user's mood query.
+    Process a question, find relevant information, and generate a response.
     """
-    # Example logic to recommend songs based on mood (replace with your actual logic)
-    recommended_songs = [
-        "Song A",
-        "Song B",
-        "Song C",
-        "Song D",
-        "Song E"
-    ]
-
-    # Format the recommendation list as a string
-    recommended_songs_str = "\n- " + "\n- ".join(recommended_songs)
-
-    return f"Here are some songs you might like based on '{mood}' mood:{recommended_songs_str}"
-
-def query_model(user_query):
-    """
-    Process a user's query, find relevant information, and generate a response.
-    """
-    if user_query == "":
-        return "Welcome to SongBot! Ask me for song recommendations based on mood."
-
-    # Example logic to identify if the user query is related to song recommendations based on mood
-    if "recommend" in user_query.lower() and ("song" in user_query.lower() or "music" in user_query.lower()):
-        mood = user_query.lower().split("recommend", 1)[1].strip()  # Extract mood from query
-        response = recommend_songs_based_on_mood(mood)
-    else:
-        relevant_segment = find_relevant_segment(user_query, segments)
-        if not relevant_segment:
-            response = "Could not find specific information. Please refine your question."
-        else:
-            response = generate_response(user_query, relevant_segment)
-
+    if question == "":
+        return "Welcome to the Song Recommendation Bot! Ask me for song recommendations based on your mood."
+    relevant_segment = find_relevant_segment(question, segments)
+    if not relevant_segment:
+        return "Could not find specific song recommendations. Please refine your question."
+    response = generate_response(question, relevant_segment)
     return response
-
 # Define the welcome message and specific topics the chatbot can provide information about
 welcome_message = """
-# 🎶: Welcome to Song Seeker!
-## Your AI-driven assistant for music curation. Created by Fenet, Lia, and Zamira of the 2024 Kode With Klossy DC Camp.
+# :musical_note: Welcome to the Song Recommendation Bot!
+## I am here to help you find the perfect songs based on your mood, specially curated for Gen Z tastes.
 """
-
 topics = """
-### Feel free to ask me for song recommendations based on mood!
-- Happy songs
-- Sad songs
-- Chill songs
-- Angry songs
-- Workout songs
+### Feel free to ask me for song recommendations for:
+- Sad mood
+- Happy mood
+- Angry mood
+- Workout
+- Chilling
+- Study
+- Eating a meal
+- Nostalgic
+- Self care
 """
-
 # Setup the Gradio Blocks interface with custom layout components
-with gr.Blocks(theme='dabble') as demo:
+with gr.Blocks() as demo:
     gr.Markdown(welcome_message)  # Display the formatted welcome message
     with gr.Row():
         with gr.Column():
             gr.Markdown(topics)  # Show the topics on the left side
     with gr.Row():
         with gr.Column():
-            question = gr.Textbox(label="Your mood (e.g., happy, sad)", placeholder="What mood are you in?")
-            answer = gr.Textbox(label="SongBot Response", placeholder="SongBot will respond here...", interactive=False, lines=10)
+            question = gr.Textbox(label="Your question", placeholder="What's your mood or activity?")
+            answer = gr.Textbox(label="Song Recommendations", placeholder="Your recommendations will appear here...", interactive=False, lines=10)
             submit_button = gr.Button("Submit")
             submit_button.click(fn=query_model, inputs=question, outputs=answer)
-
 # Launch the Gradio app to allow user interaction
 demo.launch(share=True)