Upload 5 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+music_mental_health.csv filter=lfs diff=lfs merge=lfs -text

music_mental_health.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0cbdc528fb1e62a93c1cb61f2a416072154f7c74e344cc2143e75d6abfa51d0
+size 161543173

sentiment_analysis.py

@@ -0,0 +1,26 @@
+import tensorflow as tf
+from transformers import RobertaTokenizer, TFRobertaForSequenceClassification
+
+class SentimentAnalyzer:
+    def __init__(self, model_name='roberta-base', classifier_model='arpanghoshal/EmoRoBERTa'):
+        """
+        Initializes the sentiment analyzer with the specified models.
+        :param model_name: Name of the tokenizer model
+        :param classifier_model: Name of the sentiment classification model
+        """
+        self.tokenizer = RobertaTokenizer.from_pretrained(model_name)
+        self.model = TFRobertaForSequenceClassification.from_pretrained(classifier_model)
+
+    def analyze_sentiment(self, user_input):
+        """
+        Analyzes the sentiment of the given user input.
+        :param user_input: Text input from the user
+        :return: A tuple of sentiment label and sentiment score
+        """
+        encoded_input = self.tokenizer(user_input, return_tensors="tf", truncation=True, padding=True, max_length=512)
+        outputs = self.model(encoded_input)
+        scores = tf.nn.softmax(outputs.logits, axis=-1).numpy()[0]
+        predicted_class_idx = tf.argmax(outputs.logits, axis=-1).numpy()[0]
+        sentiment_label = self.model.config.id2label[predicted_class_idx]
+        sentiment_score = scores[predicted_class_idx]
+        return sentiment_label, sentiment_score

serve_streamlit.py

@@ -0,0 +1,53 @@
+import pathlib
+import modal
+
+# Define container dependencies
+image = (
+    modal.Image.debian_slim()
+    .apt_install("git")
+    .pip_install("streamlit", "numpy", "pandas", "tensorflow", "transformers", "spotipy", "sentence_transformers")
+)
+
+stub = modal.Stub(name="streamlit_app.py", image=image)
+
+# Define the run_streamlit function
+@stub.function(
+    mounts=[
+        modal.Mount.from_local_directory(
+            local_path=pathlib.Path(__file__).parent,
+            remote_path=pathlib.Path("/app"),
+            exclude=["*.pyc", "__pycache__"]
+        )
+    ],
+    timeout=15 * 60  # Set the session timeout as needed
+)
+def run_streamlit(publish_url: bool = False):
+    import streamlit.web.bootstrap
+
+    streamlit_script_remote_path = pathlib.Path("streamlit_app.py")
+    
+    # Run the server. This function will not return until the server is shut down.
+    with modal.forward(8501) as tunnel:
+        # Reload Streamlit config with information about Modal tunnel address.
+        if publish_url:
+            stub.q.put(tunnel.url)
+        streamlit.web.bootstrap.run(
+            main_script_path=str(streamlit_script_remote_path),
+            command_line=None,
+            args=["--timeout", str(15 * 60)],  # Adjust as needed
+            flag_options={},
+        )
+
+# Additional function for creating a web endpoint
+@stub.function()
+@modal.web_endpoint(method="GET")
+def share():
+    from fastapi.responses import RedirectResponse
+
+    run_streamlit.spawn(publish_url=True)
+    url = stub.q.get()
+    return RedirectResponse(url, status_code=303)
+
+# Deploy the app
+if __name__ == "__main__":
+    stub.deploy()

song_matching.py

@@ -0,0 +1,39 @@
+import pandas as pd
+from sentence_transformers import SentenceTransformer, util
+
+class SongMatcher:
+    def __init__(self, songs_data_file, model_name="sentence-transformers/all-mpnet-base-v2"):
+        """
+        Initializes the SongMatcher with the songs data file and the SentenceTransformer model.
+        :param songs_data_file: Path to the CSV file containing songs data
+        :param model_name: Name of the SentenceTransformer model
+        """
+        self.songs_df = pd.read_csv(songs_data_file)
+        self.sim_model = SentenceTransformer(model_name)
+
+    def match_songs_with_sentiment(self, user_sentiment_label, user_sentiment_score, user_input, score_range=0.00625):
+        """
+        Matches songs from the dataset with the user's sentiment.
+        :param user_sentiment_label: The sentiment label of the user input
+        :param user_sentiment_score: The sentiment score of the user input
+        :param user_input: Text input from the user
+        :param score_range: Range for filtering songs based on sentiment score
+        :return: DataFrame of top 5 matched songs
+        """
+        # Filter songs with the same sentiment label
+        matched_songs = self.songs_df[self.songs_df['sentiment'] == user_sentiment_label]
+
+        # Calculate the score range
+        score_min = max(0, user_sentiment_score - score_range)
+        score_max = min(1, user_sentiment_score + score_range)
+
+        # Further filter songs whose scores fall within the specified range
+        matched_songs = matched_songs[(matched_songs['score'] >= score_min) & (matched_songs['score'] <= score_max)]
+
+        # Compute similarity between user input and song lyrics
+        input_vector = self.sim_model.encode(user_input)
+        matched_songs['similarity'] = matched_songs['seq'].apply(lambda x: util.pytorch_cos_sim(self.sim_model.encode(x), input_vector))
+
+        # Select the top five songs based on similarity and return
+        top_5 = matched_songs.nlargest(5, 'similarity')
+        return top_5[['song', 'artist', 'seq', 'similarity', 'sentiment', 'score']]

spotify_api.py

@@ -0,0 +1,33 @@
+import spotipy
+from spotipy.oauth2 import SpotifyClientCredentials
+
+class SpotifyClient:
+    def __init__(self, client_id, client_secret):
+        """
+        Initializes the SpotifyClient with given client credentials.
+        :param client_id: Spotify API Client ID
+        :param client_secret: Spotify API Client Secret
+        """
+        self.sp = spotipy.Spotify(client_credentials_manager=SpotifyClientCredentials(client_id, client_secret))
+
+    def get_track_id(self, song_name):
+        """
+        Searches for a track by name and returns its Spotify ID.
+        :param song_name: The name of the song to search for
+        :return: Spotify track ID or None if not found
+        """
+        results = self.sp.search(q=song_name, type='track', limit=1)
+        if results['tracks']['items']:
+            return results['tracks']['items'][0]['id']
+        else:
+            print(f"No results found for {song_name}")
+            return None
+
+    def get_track_preview_url(self, track_id):
+        """
+        Retrieves the 30-second preview URL for a given track ID.
+        :param track_id: Spotify track ID
+        :return: Preview URL or None if not available
+        """
+        track_info = self.sp.track(track_id)
+        return track_info.get('preview_url')