Update app.py

updated build fixed issues

app.py

@@ -14,22 +14,9 @@ from torch.cuda.amp import autocast
 # Set PYTORCH_CUDA_ALLOC_CONF to manage memory fragmentation
 os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:32"
 
-# Setup instructions:
-# 1. Create a virtual environment: python3 -m venv venv
-# 2. Activate the environment: source venv/bin/activate
-# 3. Install dependencies:
-#    pip install torch==2.1.0 torchvision==0.16.0 torchaudio==2.1.0 --index-url https://download.pytorch.org/whl/cu121
-#    pip install -r requirements.txt
-# 4. Install ffmpeg for MP3 export:
-#    sudo apt-get install ffmpeg
-# 5. Ensure model weights are in /home/ubuntu/ghostai_music_generator/models/musicgen-medium
-# 6. Log in to Hugging Face CLI: huggingface-cli login
-# 7. Request access to model if needed: https://huggingface.co/facebook/musicgen-medium
-
 # Check critical dependencies
 if np.__version__ != "1.23.5":
-    print(f"ERROR: NumPy version {np.__version__} is not compatible. Please install numpy==1.23.5.")
-    sys.exit(1)
+    print(f"WARNING: NumPy version {np.__version__} is being used. This script was tested with numpy==1.23.5, but proceeding anyway.")
 if not torch.__version__.startswith(("2.1.0", "2.3.1")):
     print(f"WARNING: PyTorch version {torch.__version__} may not be compatible. Expected torch==2.1.0 or 2.3.1.")
 
@@ -60,71 +47,77 @@ def print_resource_usage(stage: str):
     print(f"GPU Memory Reserved: {torch.cuda.memory_reserved() / (1024**3):.2f} GB")
     print("---------------")
 
-# 4) GENRE PROMPT FUNCTIONS (Updated for distinct song sections with balanced energy)
+# 4) GENRE PROMPT FUNCTIONS (Updated for consistency, more instruments, and popular styles)
 def set_rock_prompt():
-    return "Hard rock with a dynamic intro, expressive verse, and powerful chorus, featuring electric guitars, steady heavy drums, and deep bass"
+    return "Hard rock with dynamic electric guitars, heavy steady drums, deep groovy bass, subtle organ layers, and a hint of Red Hot Chili Peppers' funky rock energy, maintaining a cohesive structure throughout"
 
 def set_techno_prompt():
-    return "Techno with a pulsing intro, intense build-up, and energetic drop, featuring dark synths, driving bass, and rhythmic fast drums"
+    return "Techno with pulsing dark synths, driving basslines, fast rhythmic drums, atmospheric pads, and a Daft Punk-inspired house groove, keeping a consistent energetic flow"
 
 def set_jazz_prompt():
-    return "Smooth jazz with a warm intro, expressive theme, and lively outro, featuring saxophone, piano, and soft rhythmic drums"
+    return "Smooth jazz with warm saxophone leads, expressive piano chords, soft rhythmic drums, upright bass, and a Miles Davis-inspired improvisational feel, maintaining a cohesive smooth vibe"
 
 def set_classical_prompt():
-    return "Classical orchestral piece with a gentle intro, dramatic development, and grand finale, featuring strings, piano, and subtle rhythmic percussion"
+    return "Classical orchestral piece with gentle strings, expressive piano, subtle woodwinds, dramatic brass, and a Bach-inspired baroque structure, keeping a consistent classical flow"
 
 def set_hiphop_prompt():
-    return "Hip-hop with a groovy intro, rhythmic verse, and catchy hook, featuring deep bass, tight crisp drums, and funky synths"
+    return "Hip-hop with groovy deep bass, tight crisp drums, funky synths, vinyl scratches, and a modern trap influence, maintaining a consistent rhythmic groove"
+
+def set_pop_rock_prompt():
+    return "Pop rock with catchy electric guitar riffs, uplifting vocals synths, steady drums, melodic basslines, and a U2-inspired anthemic feel, keeping a consistent uplifting vibe"
+
+def set_fusion_jazz_prompt():
+    return "Fusion jazz with electric piano, funky basslines, intricate drum patterns, soaring trumpet, and a Herbie Hancock-inspired groove, maintaining a consistent fusion energy"
+
+def set_baroque_classical_prompt():
+    return "Baroque classical with harpsichord, delicate violin, cello, flute, and a Vivaldi-inspired melodic structure, keeping a consistent baroque elegance"
+
+def set_deep_house_prompt():
+    return "Deep house with warm synth chords, deep basslines, crisp hi-hats, soulful vocal chops, and a Carl Cox-inspired underground vibe, maintaining a consistent hypnotic groove"
 
 # 5) AUDIO PROCESSING FUNCTIONS
 def apply_chorus(segment):
     # Enhanced chorus effect for richer sound
-    delayed = segment - 4  # Slightly louder delayed copy at -4 dB (was -6 dB)
+    delayed = segment - 6  # Reduced gain to -6 dB for a subtler effect
     delayed = delayed.set_frame_rate(segment.frame_rate)
-    return segment.overlay(delayed, position=20)  # Increased delay to 20ms for more noticeable effect
+    return segment.overlay(delayed, position=20)
 
 def apply_eq(segment):
-    # Apply EQ: Balanced filters for cleaner sound
-    segment = segment.low_pass_filter(6000)  # Loosen low-pass filter for brighter highs
-    segment = segment.high_pass_filter(100)  # Slightly lower cutoff for low rumble
+    # Adjusted EQ for a more balanced sound
+    segment = segment.low_pass_filter(8000)  # Raised cutoff to 8kHz for brighter highs
+    segment = segment.high_pass_filter(80)  # Lowered cutoff to 80Hz for deeper bass
     return segment
 
-def apply_limiter(segment, max_db=-8.0):
-    # Apply a strict limiter to control peaks
+def apply_limiter(segment, max_db=-3.0):
+    # Apply limiter with a higher threshold to preserve dynamics
     if segment.dBFS > max_db:
-        segment = segment - (segment.dBFS - max_db)  # Reduce gain to prevent clipping
+        segment = segment - (segment.dBFS - max_db)
     return segment
 
 # 6) GENERATION & I/O FUNCTIONS
 def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p: float, temperature: float, total_duration: int, crossfade_duration: int):
-    global musicgen_model  # Use global to modify the model instance
+    global musicgen_model
     if not instrumental_prompt.strip():
         return None, "⚠️ Please enter a valid instrumental prompt!"
     try:
-        # Record start time for total duration calculation
         start_time = time.time()
 
-        # Ensure total duration is within reasonable bounds
-        total_duration = min(max(total_duration, 10), 60)  # Between 10 and 60 seconds
-        chunk_duration = 15  # Duration of each chunk (e.g., 2 chunks of 15 seconds for a 30-second track)
-        num_chunks = max(2, (total_duration + chunk_duration - 1) // chunk_duration)  # Ensure at least 2 chunks
-        chunk_duration = total_duration / num_chunks  # Adjust chunk duration to fit total duration
+        # Ensure total duration is within reasonable bounds (up to 90 seconds for longer tracks)
+        total_duration = min(max(total_duration, 10), 90)
+        chunk_duration = 15
+        num_chunks = max(2, (total_duration + chunk_duration - 1) // chunk_duration)
+        chunk_duration = total_duration / num_chunks
 
         # Generate slightly longer chunks for overlap
-        overlap_duration = min(1.0, crossfade_duration / 1000.0)  # Convert ms to seconds, max 1 second
-        generation_duration = chunk_duration + overlap_duration  # Add overlap to each chunk
+        overlap_duration = min(1.0, crossfade_duration / 1000.0)
+        generation_duration = chunk_duration + overlap_duration
 
-        # Initialize list to store audio chunks
         audio_chunks = []
         sample_rate = musicgen_model.sample_rate
 
-        # Generate audio in chunks with distinct prompts for song structure
+        # Generate audio in chunks with a consistent prompt
         for i in range(num_chunks):
-            # Vary the prompt for each chunk to create clear song sections
-            if i == 0:
-                chunk_prompt = instrumental_prompt + ", focusing on a dynamic intro and expressive verse"
-            else:
-                chunk_prompt = instrumental_prompt + ", focusing on a powerful chorus and energetic outro"
+            chunk_prompt = instrumental_prompt  # Use the same prompt for all chunks
 
             print(f"Generating chunk {i+1}/{num_chunks} on GPU (prompt: {chunk_prompt})...")
             musicgen_model.set_generation_params(
@@ -136,17 +129,15 @@ def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p
                 cfg_coef=cfg_scale
             )
 
-            # Print resource usage before each chunk
             print_resource_usage(f"Before Chunk {i+1} Generation")
 
             with torch.no_grad():
-                with autocast():  # Use mixed precision for lower VRAM usage
-                    audio_chunk = musicgen_model.generate([chunk_prompt], progress=True)[0]  # Shape: (2, samples)
+                with autocast():
+                    audio_chunk = musicgen_model.generate([chunk_prompt], progress=True)[0]
 
-            # Normalize to stereo
             audio_chunk = audio_chunk.cpu().to(dtype=torch.float32)
             if audio_chunk.dim() == 1:
-                audio_chunk = torch.stack([audio_chunk, audio_chunk], dim=0)  # Mono to stereo
+                audio_chunk = torch.stack([audio_chunk, audio_chunk], dim=0)
             elif audio_chunk.dim() == 2 and audio_chunk.shape[0] == 1:
                 audio_chunk = torch.cat([audio_chunk, audio_chunk], dim=0)
             elif audio_chunk.dim() == 2 and audio_chunk.shape[0] != 2:
@@ -158,45 +149,37 @@ def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p
             if audio_chunk.shape[0] != 2:
                 raise ValueError(f"Expected stereo audio with shape (2, samples), got shape {audio_chunk.shape}")
 
-            # Save chunk temporarily as WAV, then convert to MP3
             temp_wav_path = f"temp_chunk_{i}.wav"
             chunk_path = f"chunk_{i}.mp3"
             torchaudio.save(temp_wav_path, audio_chunk, sample_rate, bits_per_sample=24)
             segment = AudioSegment.from_wav(temp_wav_path)
-            segment = apply_limiter(segment, max_db=-8.0)  # Apply limiter early to control peaks
             segment.export(chunk_path, format="mp3", bitrate="320k")
-            os.remove(temp_wav_path)  # Clean up temporary WAV file
+            os.remove(temp_wav_path)
             audio_chunks.append(chunk_path)
 
-            # Free memory after generating each chunk
             torch.cuda.empty_cache()
             gc.collect()
-            time.sleep(0.5)  # Small delay to ensure memory is released
+            time.sleep(0.5)
             print_resource_usage(f"After Chunk {i+1} Generation")
 
-        # Combine chunks using pydub with crossfade to smooth transitions
+        # Combine chunks with crossfade
         print("Combining audio chunks...")
         final_segment = AudioSegment.from_mp3(audio_chunks[0])
         for i in range(1, len(audio_chunks)):
             next_segment = AudioSegment.from_mp3(audio_chunks[i])
-            # Apply a gentle gain boost to raise quieter sections
-            next_segment = next_segment + 2  # Boost by 2 dB to avoid amplitude dips
-            next_segment = apply_limiter(next_segment, max_db=-8.0)  # Re-apply limiter after gain boost
+            next_segment = next_segment + 1  # Reduced gain boost to +1 dB
             final_segment = final_segment.append(next_segment, crossfade=crossfade_duration)
 
-        # Trim to exact total duration (in milliseconds)
+        # Trim to exact total duration
         final_segment = final_segment[:total_duration * 1000]
 
-        # Post-process to enhance audio quality
+        # Post-process with improved dynamics
         print("Post-processing final track...")
         final_segment = apply_eq(final_segment)
         final_segment = apply_chorus(final_segment)
+        final_segment = apply_limiter(final_segment, max_db=-3.0)  # Apply limiter only once with higher threshold
+        final_segment = final_segment.normalize(headroom=-6.0)  # Increased headroom to -6 dB
 
-        # Apply final limiter and normalization with large headroom
-        final_segment = apply_limiter(final_segment, max_db=-8.0)
-        final_segment = final_segment.normalize(headroom=-10.0)  # Large headroom to prevent clipping
-
-        # Export as MP3 only
         mp3_path = "output_cleaned.mp3"
         final_segment.export(
             mp3_path,
@@ -206,11 +189,9 @@ def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p
         )
         print(f"Saved final audio to {mp3_path}")
 
-        # Clean up temporary chunk files
         for chunk_path in audio_chunks:
             os.remove(chunk_path)
 
-        # Print resource usage after generation
         print_resource_usage("After Final Generation")
         print(f"Total Generation Time: {time.time() - start_time:.2f} seconds")
 
@@ -224,7 +205,7 @@ def generate_music(instrumental_prompt: str, cfg_scale: float, top_k: int, top_p
 def clear_inputs():
     return "", 3.0, 300, 0.95, 1.0, 30, 500
 
-# 7) CUSTOM CSS
+# 7) CUSTOM CSS (Unchanged)
 css = """
 body { 
     background: linear-gradient(135deg, #0A0A0A 0%, #1C2526 100%); 
@@ -375,6 +356,10 @@ with gr.Blocks(css=css) as demo:
             jazz_btn = gr.Button("Jazz", elem_classes="genre-btn")
             classical_btn = gr.Button("Classical", elem_classes="genre-btn")
             hiphop_btn = gr.Button("Hip-Hop", elem_classes="genre-btn")
+            pop_rock_btn = gr.Button("Pop Rock", elem_classes="genre-btn")
+            fusion_jazz_btn = gr.Button("Fusion Jazz", elem_classes="genre-btn")
+            baroque_btn = gr.Button("Baroque Classical", elem_classes="genre-btn")
+            deep_house_btn = gr.Button("Deep House", elem_classes="genre-btn")
     
     with gr.Column(elem_classes="settings-container"):
         cfg_scale = gr.Slider(
@@ -412,10 +397,10 @@ with gr.Blocks(css=css) as demo:
         total_duration = gr.Slider(
             label="Total Duration (seconds)",
             minimum=10,
-            maximum=60,
+            maximum=90,
             value=30,
             step=1,
-            info="Total duration of the track (10 to 60 seconds)."
+            info="Total duration of the track (10 to 90 seconds)."
         )
         crossfade_duration = gr.Slider(
             label="Crossfade Duration (ms)",
@@ -438,6 +423,10 @@ with gr.Blocks(css=css) as demo:
     jazz_btn.click(set_jazz_prompt, inputs=None, outputs=[instrumental_prompt])
     classical_btn.click(set_classical_prompt, inputs=None, outputs=[instrumental_prompt])
     hiphop_btn.click(set_hiphop_prompt, inputs=None, outputs=[instrumental_prompt])
+    pop_rock_btn.click(set_pop_rock_prompt, inputs=None, outputs=[instrumental_prompt])
+    fusion_jazz_btn.click(set_fusion_jazz_prompt, inputs=None, outputs=[instrumental_prompt])
+    baroque_btn.click(set_baroque_classical_prompt, inputs=None, outputs=[instrumental_prompt])
+    deep_house_btn.click(set_deep_house_prompt, inputs=None, outputs=[instrumental_prompt])
     gen_btn.click(
         generate_music,
         inputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, crossfade_duration],
@@ -449,17 +438,16 @@ with gr.Blocks(css=css) as demo:
         outputs=[instrumental_prompt, cfg_scale, top_k, top_p, temperature, total_duration, crossfade_duration]
     )
 
-# 9) TURN OFF OPENAPI/DOCS to avoid the gradio-client schema bug
+# 9) TURN OFF OPENAPI/DOCS
 app = demo.launch(
     server_name="0.0.0.0",
     server_port=9999,
     share=False,
     inbrowser=False,
-    show_error=True  # keep this so you still see stack traces in console
+    show_error=True
 )
-# Access the underlying FastAPI and disable its docs
 try:
-    fastapi_app = demo._server.app  # Gradio v4.44+ puts FastAPI here
+    fastapi_app = demo._server.app
     fastapi_app.docs_url = None
     fastapi_app.redoc_url = None
     fastapi_app.openapi_url = None