import os import io import gradio as gr import torch import numpy as np import re import pronouncing # Add this to requirements.txt for syllable counting import functools # Add this for lru_cache functionality from transformers import ( AutoModelForAudioClassification, AutoFeatureExtractor, AutoTokenizer, pipeline, AutoModelForCausalLM, BitsAndBytesConfig ) from huggingface_hub import login from utils import ( load_audio, extract_audio_duration, extract_mfcc_features, format_genre_results, ensure_cuda_availability ) from emotionanalysis import MusicAnalyzer import librosa # Login to Hugging Face Hub if token is provided if "HF_TOKEN" in os.environ: login(token=os.environ["HF_TOKEN"]) # Constants GENRE_MODEL_NAME = "dima806/music_genres_classification" MUSIC_DETECTION_MODEL = "MIT/ast-finetuned-audioset-10-10-0.4593" LLM_MODEL_NAME = "Qwen/Qwen3-32B" SAMPLE_RATE = 22050 # Standard sample rate for audio processing # Check CUDA availability (for informational purposes) CUDA_AVAILABLE = ensure_cuda_availability() # Load models @functools.lru_cache(maxsize=1) def load_genre_model(): print("Loading genre classification model...") return pipeline( "audio-classification", model=GENRE_MODEL_NAME, device=0 if CUDA_AVAILABLE else -1 ) @functools.lru_cache(maxsize=1) def load_llm_pipeline(): print("Loading Qwen LLM model with 4-bit quantization...") # Configure 4-bit quantization for better performance quantization_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=True ) return pipeline( "text-generation", model=LLM_MODEL_NAME, device_map="auto", trust_remote_code=True, model_kwargs={ "torch_dtype": torch.float16, "quantization_config": quantization_config, "use_cache": True } ) # Create music analyzer instance music_analyzer = MusicAnalyzer() # Process uploaded audio file def process_audio(audio_file): if audio_file is None: return "No audio file provided", None, None, None, None, None, None try: # Load and analyze audio y, sr = load_audio(audio_file, sr=SAMPLE_RATE) # Basic audio information duration = extract_audio_duration(y, sr) # Analyze music with MusicAnalyzer music_analysis = music_analyzer.analyze_music(audio_file) # Extract key information tempo = music_analysis["rhythm_analysis"]["tempo"] time_signature = music_analysis["rhythm_analysis"]["estimated_time_signature"] emotion = music_analysis["emotion_analysis"]["primary_emotion"] theme = music_analysis["theme_analysis"]["primary_theme"] # Use genre classification pipeline genre_classifier = load_genre_model() # Resample audio to 16000 Hz for the genre model y_16k = librosa.resample(y, orig_sr=sr, target_sr=16000) # Classify genre genre_results = genre_classifier({"raw": y_16k, "sampling_rate": 16000}) # Get top genres top_genres = [(genre["label"], genre["score"]) for genre in genre_results] # Format genre results for display genre_results_text = format_genre_results(top_genres) primary_genre = top_genres[0][0] # Generate lyrics using LLM lyrics = generate_lyrics(music_analysis, primary_genre, duration) # Prepare analysis summary analysis_summary = f""" ### Music Analysis Results **Duration:** {duration:.2f} seconds **Tempo:** {tempo:.1f} BPM **Time Signature:** {time_signature} **Key:** {music_analysis["tonal_analysis"]["key"]} {music_analysis["tonal_analysis"]["mode"]} **Primary Emotion:** {emotion} **Primary Theme:** {theme} **Top Genre:** {primary_genre} {genre_results_text} """ return analysis_summary, lyrics, tempo, time_signature, emotion, theme, primary_genre except Exception as e: error_msg = f"Error processing audio: {str(e)}" print(error_msg) return error_msg, None, None, None, None, None, None def generate_lyrics(music_analysis, genre, duration): try: # Extract meaningful information for context tempo = music_analysis["rhythm_analysis"]["tempo"] key = music_analysis["tonal_analysis"]["key"] mode = music_analysis["tonal_analysis"]["mode"] emotion = music_analysis["emotion_analysis"]["primary_emotion"] theme = music_analysis["theme_analysis"]["primary_theme"] # Load LLM pipeline text_generator = load_llm_pipeline() # Construct prompt for the LLM prompt = f"""As a professional songwriter, write ONLY the lyrics for a {genre} song with these specifications: - Key: {key} {mode} - Tempo: {tempo} BPM - Emotion: {emotion} - Theme: {theme} - Duration: {duration:.1f} seconds - Time signature: {music_analysis["rhythm_analysis"]["estimated_time_signature"]} DO NOT include any explanations, thinking process, or commentary about the lyrics. DO NOT use bullet points or numbering. The output should ONLY contain the actual song lyrics, formatted as they would appear in a song. """ # Generate lyrics using the LLM pipeline generation_result = text_generator( prompt, max_new_tokens=1024, do_sample=True, temperature=0.7, top_p=0.9, return_full_text=False ) lyrics = generation_result[0]["generated_text"] # Additional post-processing to remove common thinking patterns lyrics = re.sub(r'^(Here are|Here is|These are).*?:\s*', '', lyrics, flags=re.IGNORECASE) lyrics = re.sub(r'^Title:.*?$', '', lyrics, flags=re.MULTILINE).strip() lyrics = re.sub(r'^Verse( \d+)?:.*?$', '', lyrics, flags=re.MULTILINE).strip() lyrics = re.sub(r'^Chorus:.*?$', '', lyrics, flags=re.MULTILINE).strip() lyrics = re.sub(r'^Bridge:.*?$', '', lyrics, flags=re.MULTILINE).strip() lyrics = re.sub(r'^Intro:.*?$', '', lyrics, flags=re.MULTILINE).strip() lyrics = re.sub(r'^Outro:.*?$', '', lyrics, flags=re.MULTILINE).strip() return lyrics except Exception as e: error_msg = f"Error generating lyrics: {str(e)}" print(error_msg) return error_msg # Create Gradio interface def create_interface(): with gr.Blocks(title="Music Analysis & Lyrics Generator") as demo: gr.Markdown("# Music Analysis & Lyrics Generator") gr.Markdown("Upload a music file or record audio to analyze it and generate matching lyrics") with gr.Row(): with gr.Column(scale=1): audio_input = gr.Audio( label="Upload or Record Audio", type="filepath", sources=["upload", "microphone"] ) analyze_btn = gr.Button("Analyze and Generate Lyrics", variant="primary") with gr.Column(scale=2): with gr.Tab("Analysis"): analysis_output = gr.Textbox(label="Music Analysis Results", lines=10) with gr.Row(): tempo_output = gr.Number(label="Tempo (BPM)") time_sig_output = gr.Textbox(label="Time Signature") emotion_output = gr.Textbox(label="Primary Emotion") theme_output = gr.Textbox(label="Primary Theme") genre_output = gr.Textbox(label="Primary Genre") with gr.Tab("Generated Lyrics"): lyrics_output = gr.Textbox(label="Generated Lyrics", lines=20) # Set up event handlers analyze_btn.click( fn=process_audio, inputs=[audio_input], outputs=[analysis_output, lyrics_output, tempo_output, time_sig_output, emotion_output, theme_output, genre_output] ) gr.Markdown(""" ## How it works 1. Upload or record a music file 2. The system analyzes tempo, beats, time signature and other musical features 3. It detects emotion, theme, and music genre 4. Using this information, it generates lyrics that match the style and length of your music """) return demo # Launch the app demo = create_interface() if __name__ == "__main__": demo.launch() else: # For Hugging Face Spaces app = demo