.

app.py

@@ -59,25 +59,12 @@ def create_lyrics_prompt(classification_results, song_structure):
     """Create a prompt for lyrics generation based on classification results and desired structure"""
     # Get the top genres and characteristics
     main_style = classification_results[0]['label']
-    main_confidence = float(classification_results[0]['score'].strip('%'))
     secondary_elements = [result['label'] for result in classification_results[1:3]]
     
-    # Create a simpler prompt with example structure
-    prompt = f"""Here's a {main_style} song with {', '.join(secondary_elements)} elements:
-
-[Verse 1]
-The melody rings through the air tonight
-Like a gentle whisper in the light
-Every note tells a story so clear
-Creating magic for all to hear
-
-[Chorus]
-Let the rhythm flow and shine
-Feel the music so divine
-Every moment, every sound
-Brings the joy that we have found
-
-Now continue with your own lyrics in this style:
+    # Create a focused prompt for lyrics generation
+    prompt = f"""Write lyrics for a song.
+Genre: {main_style}
+Musical elements: {', '.join(secondary_elements)}
 
 [Verse 1]"""
     return prompt
@@ -140,49 +127,62 @@ def format_lyrics(generated_text, song_structure):
     return "\n".join(lines)
 
 def generate_lyrics_with_retry(prompt, song_structure, max_retries=5, initial_wait=2):
-    """Generate lyrics using GPT2-Medium with retry logic"""
+    """Generate lyrics using GPT2 with retry logic"""
     wait_time = initial_wait
     
     for attempt in range(max_retries):
         try:
             response = requests.post(
-                LYRICS_API_URL,
+                "https://api-inference.huggingface.co/models/gpt2",  # Using base GPT-2
                 headers=headers,
                 json={
                     "inputs": prompt,
                     "parameters": {
-                        "max_new_tokens": song_structure['tokens'],
-                        "temperature": 0.7,  # Lower temperature for more focused output
-                        "top_p": 0.85,
+                        "max_new_tokens": 150,  # Shorter output
+                        "temperature": 0.9,  # More creative
+                        "top_k": 50,  # Standard top-k sampling
                         "do_sample": True,
                         "return_full_text": False,
-                        "repetition_penalty": 1.1,  # Reduced repetition penalty
-                        "presence_penalty": 0.3,
-                        "frequency_penalty": 0.3
+                        "num_return_sequences": 3  # Generate multiple sequences
                     }
                 }
             )
             
             if response.status_code == 200:
-                result = response.json()
-                if isinstance(result, list) and len(result) > 0:
-                    generated_text = result[0].get("generated_text", "")
+                results = response.json()
+                if not isinstance(results, list) or not results:
+                    continue
+                
+                # Try each generated sequence
+                for result in results:
+                    generated_text = result.get("generated_text", "")
                     if not generated_text:
                         continue
-                        
-                    formatted_lyrics = format_lyrics(generated_text, song_structure)
-                    
-                    # Verify we have actual content and it looks like lyrics
-                    content_lines = [l for l in formatted_lyrics.split('\n') 
-                                   if l.strip() and not l.strip().startswith('[') and l.strip() != '...']
                     
-                    # More lenient line length check
-                    if len(content_lines) < 4 or any(len(line.split()) > 20 for line in content_lines):
-                        if attempt < max_retries - 1:
-                            print("Generated text doesn't look like lyrics, retrying...")
-                            continue
+                    # Basic cleaning
+                    lines = [line.strip() for line in generated_text.split('\n') 
+                            if line.strip() and not line.strip().startswith(('[', '#', '`'))]
                     
-                    return formatted_lyrics
+                    # Check if we have enough content
+                    if len(lines) >= 4:
+                        # Format into verses and chorus
+                        formatted_lyrics = []
+                        formatted_lyrics.append("[Verse 1]")
+                        formatted_lyrics.extend(lines[:4])
+                        
+                        if song_structure['choruses'] > 0:
+                            formatted_lyrics.append("\n[Chorus 1]")
+                            formatted_lyrics.extend(lines[4:8] if len(lines) >= 8 else ["..." for _ in range(4)])
+                        
+                        if song_structure['verses'] > 1:
+                            formatted_lyrics.append("\n[Verse 2]")
+                            formatted_lyrics.extend(lines[8:12] if len(lines) >= 12 else ["..." for _ in range(4)])
+                        
+                        return "\n".join(formatted_lyrics)
+                
+                # If we get here, none of the sequences were good enough
+                if attempt < max_retries - 1:
+                    continue
                     
             elif response.status_code == 503:
                 print(f"Model loading, attempt {attempt + 1}/{max_retries}. Waiting {wait_time} seconds...")