.

app.py

@@ -61,12 +61,16 @@ def create_lyrics_prompt(classification_results, song_structure):
     main_style = classification_results[0]['label']
     secondary_elements = [result['label'] for result in classification_results[1:3]]
     
-    # Create a focused prompt for lyrics generation
-    prompt = f"""Write lyrics for a song.
-Genre: {main_style}
-Musical elements: {', '.join(secondary_elements)}
+    # Create a more specific prompt for song lyrics
+    prompt = f"""Write a short song with musical elements.
 
-[Verse 1]"""
+Style: {main_style}
+Elements: {', '.join(secondary_elements)}
+
+Start with the first verse:
+
+[Verse 1]
+"""
     return prompt
 
 def format_lyrics(generated_text, song_structure):
@@ -132,60 +136,78 @@ def generate_lyrics_with_retry(prompt, song_structure, max_retries=5, initial_wa
     
     for attempt in range(max_retries):
         try:
+            print(f"\nAttempt {attempt + 1}: Generating lyrics...")
+            print(f"Using prompt:\n{prompt}")
+            
             response = requests.post(
-                "https://api-inference.huggingface.co/models/gpt2",  # Using base GPT-2
+                "https://api-inference.huggingface.co/models/distilgpt2",  # Using DistilGPT2 for more reliable generation
                 headers=headers,
                 json={
                     "inputs": prompt,
                     "parameters": {
-                        "max_new_tokens": 150,  # Shorter output
-                        "temperature": 0.9,  # More creative
-                        "top_k": 50,  # Standard top-k sampling
+                        "max_new_tokens": 100,  # Shorter output for more focused generation
+                        "temperature": 0.8,
+                        "top_p": 0.9,
                         "do_sample": True,
                         "return_full_text": False,
-                        "num_return_sequences": 3  # Generate multiple sequences
+                        "num_return_sequences": 1,  # Single sequence for now
+                        "stop": ["\n\n", "[End]"]
                     }
                 }
             )
             
+            print(f"Response status: {response.status_code}")
+            
             if response.status_code == 200:
-                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
-                    
-                    # Basic cleaning
-                    lines = [line.strip() for line in generated_text.split('\n') 
-                            if line.strip() and not line.strip().startswith(('[', '#', '`'))]
+                try:
+                    result = response.json()
+                    print(f"Raw response: {result}")
                     
-                    # 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 isinstance(result, list) and len(result) > 0:
+                        generated_text = result[0].get("generated_text", "")
+                        if not generated_text:
+                            print("No text generated, retrying...")
+                            continue
                         
-                        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)])
+                        # Clean up the generated text
+                        lines = []
+                        current_lines = []
                         
-                        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)])
+                        for line in generated_text.split('\n'):
+                            line = line.strip()
+                            if not line or line.startswith(('```', '###', '[')):
+                                continue
+                            if len(line.split()) <= 15:  # Only include reasonably-sized lines
+                                current_lines.append(line)
+                                if len(current_lines) >= 4:
+                                    break
                         
-                        return "\n".join(formatted_lyrics)
-                
-                # If we get here, none of the sequences were good enough
-                if attempt < max_retries - 1:
-                    continue
+                        if len(current_lines) >= 4:
+                            # Format into song structure
+                            lines.append("[Verse 1]")
+                            lines.extend(current_lines[:4])
+                            
+                            if song_structure['choruses'] > 0:
+                                lines.append("\n[Chorus]")
+                                lines.extend([
+                                    "Let the music play",
+                                    "In our special way",
+                                    "Feel the rhythm flow",
+                                    "As the melodies grow"
+                                ])
+                            
+                            return "\n".join(lines)
+                        else:
+                            print(f"Not enough valid lines generated (got {len(current_lines)}), retrying...")
+                    else:
+                        print("Invalid response format, retrying...")
+                except Exception as e:
+                    print(f"Error processing response: {str(e)}")
+                    if attempt < max_retries - 1:
+                        continue
                     
             elif response.status_code == 503:
-                print(f"Model loading, attempt {attempt + 1}/{max_retries}. Waiting {wait_time} seconds...")
+                print(f"Model loading, waiting {wait_time} seconds...")
                 time.sleep(wait_time)
                 wait_time *= 1.5
                 continue
@@ -196,7 +218,7 @@ def generate_lyrics_with_retry(prompt, song_structure, max_retries=5, initial_wa
                 return f"Error generating lyrics: {response.text}"
                 
         except Exception as e:
-            print(f"Error on attempt {attempt + 1}: {str(e)}")
+            print(f"Exception during generation: {str(e)}")
             if attempt < max_retries - 1:
                 time.sleep(wait_time)
                 wait_time *= 1.5