Upload 5 files

README.md

@@ -1,3 +1,33 @@
+# Songsmith AI: Music Lyric Creator
+
+This Hugging Face Space generates professional-quality song lyrics with proper musical structure. It creates catchy, singable lyrics with verse-chorus format and genre-specific style enhancements.
+
+## Features
+
+- **Genre-specific enhancements**: Each genre (pop, rock, rap, folk, r&b, country, indie, dance) has custom intensifiers, metaphors, and structural patterns
+- **Professional song structure**: Proper verse-chorus format with optional bridge sections
+- **Enhanced rhyming**: Intelligent rhyme patterns that match your selected scheme
+- **Musical phrasing**: Short, catchy lines optimized for singing
+- **Emotional hooks**: Repetition and emphasis in the right places
+
+## How to Use
+
+1. Enter a theme or topic for your song
+2. Select a music genre (affects style, metaphors, and structure)
+3. Choose a rhyme scheme (AABB or ABAB)
+4. Adjust the maximum length as needed (longer = more sections)
+5. Click "Generate Lyrics" and enjoy your AI-created song!
+
+## Technical Details
+
+- Built with Gradio 5.1.0
+- Uses Hugging Face Transformers with DistilGPT-2
+- Enhanced with custom lyric processing modules:
+  - IntensifierGenerator: Adds genre-specific intensifiers and metaphors
+  - RhymeEnhancer: Improves rhyming patterns
+  - SongStructureEnhancer: Creates proper verse-chorus-bridge structure
+- Optimized for free-tier Spaces
+
 ---
 title: Harmonyaixlyricgenerator
 emoji: 🌍
@@ -10,5 +40,3 @@ pinned: false
 license: mit
 short_description: Lyric generator
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,259 @@
+from transformers import pipeline
+import gradio as gr
+import random
+from lyric_enhancer import IntensifierGenerator, RhymeEnhancer, SongStructureEnhancer
+
+# Initialize models suitable for free tier
+try:
+    # Try to load the primary model
+    generator = pipeline('text-generation', model='distilgpt2')
+    # Keep a backup model option ready
+    backup_model_name = 'gpt2'
+except Exception as e:
+    print(f"Error loading primary model: {e}")
+    # Fallback to an even smaller model if needed
+    generator = pipeline('text-generation', model='gpt2')
+    backup_model_name = None
+
+def generate_lyrics(theme, genre, rhyme_scheme="AABB", max_length=150):
+    """Generate song lyrics based on input parameters"""
+    
+    # Create enhancers
+    intensifier = IntensifierGenerator(genre=genre)
+    rhymer = RhymeEnhancer()
+    structure_enhancer = SongStructureEnhancer(genre=genre)
+    
+    # Build a more musical prompt
+    prompt = f"""Write a catchy {genre} song about {theme} with {rhyme_scheme} rhyme pattern.
+Keep lines short and musical. Include emotional hooks and repetition.
+
+[Verse 1]
+"""
+    
+    try:
+        # Increase temperature for more creativity and reduce repetition
+        result = generator(prompt, 
+                          max_length=max_length, 
+                          num_return_sequences=1,
+                          temperature=0.9,  # Increased from 0.7
+                          top_p=0.92,       # Slightly increased
+                          repetition_penalty=1.2)  # Added to reduce repetition
+        
+        # Extract the generated text
+        lyrics = result[0]['generated_text']
+        
+        # Check if we got repetitive content
+        if lyrics.count("[Verse]") > 3 or lyrics.count("Write a") > 1:
+            raise ValueError("Repetitive output detected")
+            
+    except Exception as e:
+        print(f"Error with primary generation: {e}")
+        
+        # Try with a simpler prompt
+        simple_prompt = f"{genre} song lyrics about {theme}:\n\n[Verse 1]\n"
+        
+        try:
+            # Try with different parameters
+            result = generator(simple_prompt, 
+                              max_length=max_length, 
+                              num_return_sequences=1,
+                              temperature=1.0,
+                              top_p=0.95,
+                              repetition_penalty=1.5)
+            
+            lyrics = result[0]['generated_text']
+        except Exception as e2:
+            print(f"Error with fallback generation: {e2}")
+            return f"Sorry, I couldn't generate lyrics at this time. Please try again with a different theme or genre."
+    
+    # Better handling of output formatting
+    # Find the first occurrence of [Verse] or [Verse 1] and keep everything after it
+    verse_index = max(lyrics.find("[Verse]"), lyrics.find("[Verse 1]"))
+    
+    if verse_index != -1:
+        # Keep everything from [Verse] onwards
+        formatted_lyrics = lyrics[verse_index:].strip()
+    else:
+        # If no verse markers found, try to find the actual content
+        lines = lyrics.split("\n")
+        # Skip empty lines and prompt-related lines
+        content_lines = []
+        skip_keywords = ["Write", "catchy", "rhyme pattern", "Keep lines", "Include"]
+        
+        for line in lines:
+            # Skip empty lines and lines containing prompt keywords
+            if not line.strip() or any(keyword in line for keyword in skip_keywords):
+                continue
+            content_lines.append(line)
+        
+        formatted_lyrics = "\n".join(content_lines).strip()
+        
+        # If we couldn't extract anything meaningful, use a generic message
+        if not formatted_lyrics or len(formatted_lyrics.split()) < 5:
+            return "I couldn't generate good lyrics with this theme. Please try a different theme or genre."
+    
+    # Check for repetitive content
+    lines = formatted_lyrics.split("\n")
+    unique_lines = set(line.strip() for line in lines if line.strip())
+    
+    # If we have very few unique lines compared to total lines, it's repetitive
+    if len(lines) > 5 and len(unique_lines) < len(lines) / 2:
+        return "The model generated repetitive content. Please try again with a different theme or genre."
+    
+    # Apply our enhancers to make the lyrics more musical
+    
+    # 1. First, enhance the structure
+    enhanced_lyrics = structure_enhancer.enhance_structure(formatted_lyrics, add_bridge=(max_length > 150))
+    
+    # 2. Apply line-by-line enhancements
+    enhanced_lines = []
+    current_section = None
+    section_lines = []
+    
+    for line in enhanced_lyrics.split("\n"):
+        # Track sections for rhyming purposes
+        if line.startswith("["):
+            # Process previous section
+            if section_lines and current_section:
+                # Apply rhyme enhancement to the section
+                rhymed_lines = rhymer.enhance_section(section_lines, genre)
+                enhanced_lines.extend(rhymed_lines)
+                section_lines = []
+            
+            # Start new section
+            enhanced_lines.append(line)
+            current_section = line
+            continue
+        
+        # Apply intensifiers to individual lines
+        intensified_line = intensifier.generate(line)
+        section_lines.append(intensified_line)
+    
+    # Process the last section
+    if section_lines and current_section:
+        rhymed_lines = rhymer.enhance_section(section_lines, genre)
+        enhanced_lines.extend(rhymed_lines)
+    
+    # Final enhanced lyrics
+    formatted_lyrics = "\n".join(enhanced_lines)
+    
+    return formatted_lyrics
+
+# Custom CSS for better appearance
+css = """
+.container {
+    max-width: 900px;
+    margin: auto;
+    padding-top: 1.5rem;
+}
+.title {
+    text-align: center;
+    color: #7c3aed;
+    margin-bottom: 1rem;
+}
+.subtitle {
+    text-align: center;
+    color: #6b7280;
+    margin-bottom: 2rem;
+}
+.generate-btn {
+    background-color: #7c3aed !important;
+}
+.footer {
+    text-align: center;
+    margin-top: 2rem;
+    color: #6b7280;
+    font-size: 0.875rem;
+}
+"""
+
+# Example themes for the interface
+examples = [
+    ["heartbreak and moving on", "pop", "AABB", 150],
+    ["dancing all night", "dance", "ABAB", 150],
+    ["fighting for your dreams", "rock", "AABB", 180],
+    ["summer romance", "folk", "ABAB", 150],
+    ["city lights and late nights", "rap", "ABAB", 200],
+    ["lost love and redemption", "country", "AABB", 180],
+    ["finding yourself", "indie", "ABAB", 170],
+    ["midnight feelings", "r&b", "AABB", 160],
+]
+
+# Create Gradio interface with a custom theme
+with gr.Blocks(css=css, theme="soft") as demo:
+    with gr.Column(elem_classes="container"):
+        gr.Markdown("# 🎵 Songsmith AI: Music Lyric Creator", elem_classes="title")
+        gr.Markdown("Create catchy, singable song lyrics with verse-chorus structure and genre-specific style", elem_classes="subtitle")
+        
+        with gr.Row():
+            with gr.Column():
+                theme_input = gr.Textbox(
+                    label="Theme or Topic",
+                    placeholder="Enter a theme (e.g., lost in the forest)",
+                    info="What should your song be about?"
+                )
+                genre_input = gr.Dropdown(
+                    ["pop", "rock", "folk", "rap", "r&b", "country", "indie", "dance"], 
+                    label="Music Genre",
+                    value="pop",
+                    info="Select the musical style for genre-specific enhancements"
+                )
+                rhyme_input = gr.Dropdown(
+                    ["AABB", "ABAB"], 
+                    label="Rhyme Scheme",
+                    value="AABB",
+                    info="AABB: consecutive lines rhyme, ABAB: alternating lines rhyme"
+                )
+                length_slider = gr.Slider(
+                    50, 200, value=150, 
+                    label="Maximum Length",
+                    info="Longer text = more content but may be less coherent"
+                )
+                generate_btn = gr.Button("✨ Generate Lyrics", elem_classes="generate-btn")
+            
+            with gr.Column():
+                output = gr.Textbox(
+                    label="Generated Lyrics", 
+                    lines=12,
+                    show_copy_button=True
+                )
+        
+        gr.Examples(
+            examples=examples,
+            inputs=[theme_input, genre_input, rhyme_input, length_slider],
+            outputs=output,
+            fn=generate_lyrics,
+            cache_examples=True,
+        )
+        
+        gr.Markdown(
+            """
+            ### How to use
+            1. Enter a theme or topic for your song
+            2. Select a music genre (affects style, metaphors, and structure)
+            3. Choose a rhyme scheme
+            4. Adjust the length as needed (longer = more sections)
+            5. Click "Generate Lyrics" and enjoy your AI-created song!
+            
+            ### Features
+            - Genre-specific intensifiers and metaphors
+            - Enhanced rhyming patterns
+            - Proper song structure with verse-chorus format
+            - Bridge sections in longer songs
+            - Catchy, singable lines optimized for each genre
+            
+            ---
+            
+            *Note: This app uses a lightweight AI model (DistilGPT-2) enhanced with specialized lyric processing.*
+            """,
+            elem_classes="footer"
+        )
+    
+    generate_btn.click(
+        generate_lyrics,
+        inputs=[theme_input, genre_input, rhyme_input, length_slider],
+        outputs=output
+    )
+
+# Launch the app
+demo.launch()

lyric_enhancer.py

@@ -0,0 +1,353 @@
+import random
+
+class IntensifierGenerator:
+    def __init__(self, genre="default", use_synonyms=True, use_metaphors=True):
+        self.genre = genre
+        self.use_synonyms = use_synonyms
+        self.use_metaphors = use_metaphors
+        self.intensifier_pool = self._load_intensifiers()
+
+    def _load_intensifiers(self):
+        base_pool = {
+            "default": {
+                "synonyms": ["wild", "burning", "endless", "raw"],
+                "metaphors": ["like a comet", "like thunder", "like wildfire"]
+            },
+            "pop": {
+                "synonyms": ["electric", "neon", "glossy", "magnetic"],
+                "metaphors": ["like a spotlight", "like glitter", "like a dream"]
+            },
+            "rap": {
+                "synonyms": ["cold", "lit", "savage", "dope"],
+                "metaphors": ["like a flex", "like a cipher", "like a drop"]
+            },
+            "rock": {
+                "synonyms": ["gritty", "loud", "reckless", "feral"],
+                "metaphors": ["like a riot", "like a storm", "like a scream"]
+            },
+            "folk": {
+                "synonyms": ["rustic", "earthy", "timeless", "weathered"],
+                "metaphors": ["like the mountains", "like the wind", "like an old tale"]
+            },
+            "r&b": {
+                "synonyms": ["smooth", "sultry", "silky", "deep"],
+                "metaphors": ["like midnight", "like honey", "like a slow dance"]
+            },
+            "country": {
+                "synonyms": ["dusty", "honest", "heartfelt", "rugged"],
+                "metaphors": ["like an open road", "like a sunset", "like a whiskey glass"]
+            },
+            "indie": {
+                "synonyms": ["quirky", "intimate", "ethereal", "raw"],
+                "metaphors": ["like a polaroid", "like a whisper", "like faded jeans"]
+            },
+            "dance": {
+                "synonyms": ["pulsing", "euphoric", "vibrant", "electric"],
+                "metaphors": ["like a neon sign", "like a heartbeat", "like the night"]
+            }
+        }
+        return base_pool.get(self.genre.lower(), base_pool["default"])
+
+    def generate(self, base_line):
+        """Add genre-specific intensifiers to a line"""
+        # Don't modify section headers
+        if base_line.strip().startswith("[") and base_line.strip().endswith("]"):
+            return base_line
+            
+        # Don't modify very short lines or empty lines
+        if not base_line.strip() or len(base_line.split()) < 3:
+            return base_line
+            
+        # Only enhance some lines (not every line)
+        if random.random() > 0.4:  # 40% chance to enhance
+            return base_line
+            
+        intensifiers = []
+        if self.use_synonyms and random.random() > 0.5:
+            intensifiers.append(random.choice(self.intensifier_pool["synonyms"]))
+        if self.use_metaphors and random.random() > 0.7:  # Less frequent metaphors
+            intensifiers.append(random.choice(self.intensifier_pool["metaphors"]))
+            
+        if not intensifiers:
+            return base_line
+            
+        # Add the intensifier in a natural position
+        words = base_line.split()
+        if len(words) > 4:
+            # Insert at a natural break point
+            insert_pos = len(words) // 2
+            words.insert(insert_pos, random.choice(intensifiers))
+            return " ".join(words)
+        else:
+            # Add at the end for short lines
+            return f"{base_line} {random.choice(intensifiers)}"
+
+
+class RhymeEnhancer:
+    """Enhance rhyming in lyrics"""
+    
+    def __init__(self):
+        self.rhyme_endings = {
+            "pop": ["ight", "ay", "ove", "art", "ame"],
+            "rock": ["own", "ire", "ead", "ight", "one"],
+            "rap": ["ay", "ow", "ack", "op", "ame"],
+            "folk": ["ay", "ight", "ome", "and", "ow"],
+            "r&b": ["ove", "ight", "ay", "oul", "ime"],
+            "country": ["oad", "eart", "ome", "ight", "ay"],
+            "indie": ["ight", "own", "ay", "ime", "ow"],
+            "dance": ["ight", "ay", "ove", "own", "ire"]
+        }
+        
+    def get_rhyme_ending(self, genre):
+        """Get a rhyme ending for the given genre"""
+        genre = genre.lower()
+        if genre in self.rhyme_endings:
+            return random.choice(self.rhyme_endings[genre])
+        return random.choice(self.rhyme_endings["pop"])  # Default to pop
+        
+    def enhance_line(self, line, rhyme_ending):
+        """Try to make a line end with the given rhyme"""
+        if not line.strip() or line.strip().startswith("["):
+            return line
+            
+        # Only enhance some lines
+        if random.random() > 0.3:  # 30% chance to enhance
+            return line
+            
+        words = line.split()
+        if len(words) < 3:
+            return line
+            
+        # Try to find a word that could be replaced with a rhyming word
+        last_word = words[-1].lower().rstrip(",.!?;:")
+        
+        # Simple rhyming word replacements
+        rhyme_words = {
+            "ight": ["night", "light", "bright", "sight", "right", "tight"],
+            "ay": ["day", "way", "stay", "play", "away", "today"],
+            "ove": ["love", "above", "dove", "shove", "glove"],
+            "art": ["heart", "start", "part", "chart", "smart"],
+            "ame": ["fame", "game", "name", "flame", "shame"],
+            "own": ["down", "town", "crown", "brown", "frown"],
+            "ire": ["fire", "desire", "wire", "higher", "inspire"],
+            "ead": ["head", "instead", "spread", "dread", "thread"],
+            "one": ["stone", "alone", "bone", "tone", "zone"],
+            "ack": ["back", "track", "black", "stack", "attack"],
+            "op": ["top", "stop", "drop", "shop", "pop"],
+            "ome": ["home", "roam", "dome", "chrome", "foam"],
+            "and": ["hand", "stand", "band", "land", "grand"],
+            "ow": ["now", "how", "bow", "allow", "somehow"],
+            "oul": ["soul", "control", "roll", "whole", "goal"],
+            "ime": ["time", "crime", "prime", "sublime", "climb"],
+            "oad": ["road", "load", "code", "mode", "showed"],
+            "eart": ["heart", "start", "part", "chart", "smart"],
+        }
+        
+        if rhyme_ending in rhyme_words:
+            # Replace the last word with a rhyming word
+            words[-1] = random.choice(rhyme_words[rhyme_ending])
+            return " ".join(words)
+            
+        return line
+        
+    def enhance_section(self, lines, genre):
+        """Enhance rhyming in a section of lyrics"""
+        if not lines:
+            return lines
+            
+        # Choose a rhyme ending for this section
+        rhyme_ending = self.get_rhyme_ending(genre)
+        
+        # Enhance every other line to create an ABAB or AABB pattern
+        enhanced_lines = []
+        for i, line in enumerate(lines):
+            if i % 2 == 1:  # Every other line
+                enhanced_lines.append(self.enhance_line(line, rhyme_ending))
+            else:
+                enhanced_lines.append(line)
+                
+        return enhanced_lines
+
+
+class SongStructureEnhancer:
+    """Enhance the structure of song lyrics"""
+    
+    def __init__(self, genre="pop"):
+        self.genre = genre.lower()
+        self.chorus_templates = self._load_chorus_templates()
+        
+    def _load_chorus_templates(self):
+        """Load chorus templates by genre"""
+        templates = {
+            "pop": [
+                "Baby, {0}\nYeah, {0}",
+                "{0}\nI can't get enough\n{0}\nIt's never too much",
+                "Oh-oh-oh\n{0}\nYeah-yeah-yeah\n{0}",
+                "{0}\nAgain and again\n{0}\nUntil the end"
+            ],
+            "rock": [
+                "{0}\nIt's burning inside\n{0}\nI won't be denied",
+                "Yeah! {0}\nWoah! {0}",
+                "{0}\nI'm breaking free\n{0}\nCan't you see",
+                "{0}\nIt's do or die\n{0}\nReach for the sky"
+            ],
+            "rap": [
+                "{0}\nThat's right\n{0}\nAll night",
+                "{0}\nYou know what I'm saying\n{0}\nNo delaying",
+                "{0}\nFor real\n{0}\nThat's the deal",
+                "{0}\nYeah\n{0}\nUh"
+            ],
+            "folk": [
+                "{0}\nThrough the years\n{0}\nDespite our fears",
+                "{0}\nLike the river flows\n{0}\nEverybody knows",
+                "{0}\nTime will tell\n{0}\nAll is well",
+                "{0}\nDay by day\n{0}\nCome what may"
+            ],
+            "r&b": [
+                "Ooh baby, {0}\nYou know that {0}",
+                "{0}\nSo smooth\n{0}\nIn the groove",
+                "{0}\nAll night long\n{0}\nSo strong",
+                "{0}\nYou and me\n{0}\nDestiny"
+            ],
+            "country": [
+                "{0}\nDown that old road\n{0}\nCarrying that load",
+                "{0}\nIn my heart\n{0}\nRight from the start",
+                "{0}\nDay by day\n{0}\nCome what may",
+                "{0}\nTrue and blue\n{0}\nThrough and through"
+            ],
+            "indie": [
+                "{0}\nIn my mind\n{0}\nHard to find",
+                "{0}\nLike a dream\n{0}\nNothing's as it seems",
+                "{0}\nFading light\n{0}\nInto the night",
+                "{0}\nWe'll see\n{0}\nJust let it be"
+            ],
+            "dance": [
+                "{0}\nFeel the beat\n{0}\nSweep you off your feet",
+                "{0}\nAll night long\n{0}\nCan't go wrong",
+                "{0}\nMove your body\n{0}\nEverybody",
+                "{0}\nDon't stop now\n{0}\nShow me how"
+            ]
+        }
+        return templates.get(self.genre, templates["pop"])
+        
+    def create_chorus(self, verse_line):
+        """Create a chorus based on a line from the verse"""
+        if not verse_line or verse_line.startswith("["):
+            return ["[Chorus]", "We're living in the moment", "Feeling so alive"]
+            
+        # Extract a short phrase from the verse line
+        words = verse_line.split()
+        if len(words) >= 4:
+            phrase = " ".join(words[-3:])
+        else:
+            phrase = verse_line
+            
+        # Apply a chorus template
+        template = random.choice(self.chorus_templates)
+        chorus_text = template.format(phrase)
+        
+        # Split into lines and add the chorus header
+        chorus_lines = ["[Chorus]"] + chorus_text.split("\n")
+        return chorus_lines
+        
+    def create_bridge(self):
+        """Create a bridge section"""
+        bridge_templates = [
+            ["[Bridge]", "And now I see", "Everything has changed", "Nothing stays the same"],
+            ["[Bridge]", "Take me higher", "Set my soul on fire", "This is my desire"],
+            ["[Bridge]", "Breaking through", "Starting something new", "I'm coming back to you"],
+            ["[Bridge]", "In between", "Not what it seems", "Living in a dream"]
+        ]
+        return random.choice(bridge_templates)
+        
+    def enhance_structure(self, lyrics, add_bridge=True):
+        """Enhance the structure of the lyrics"""
+        if not lyrics:
+            return lyrics
+            
+        lines = lyrics.split("\n")
+        
+        # Find verse and chorus sections
+        verse_sections = []
+        chorus_section = None
+        current_section = []
+        current_type = None
+        
+        for line in lines:
+            if "[Verse" in line:
+                # Save previous section
+                if current_type == "verse" and current_section:
+                    verse_sections.append(current_section)
+                elif current_type == "chorus" and current_section:
+                    chorus_section = current_section
+                    
+                # Start new verse section
+                current_section = [line]
+                current_type = "verse"
+            elif "[Chorus]" in line:
+                # Save previous section
+                if current_type == "verse" and current_section:
+                    verse_sections.append(current_section)
+                    
+                # Start new chorus section
+                current_section = [line]
+                current_type = "chorus"
+            else:
+                current_section.append(line)
+                
+        # Save the last section
+        if current_type == "verse" and current_section:
+            verse_sections.append(current_section)
+        elif current_type == "chorus" and current_section:
+            chorus_section = current_section
+            
+        # If no chorus found, create one from the first verse
+        if not chorus_section and verse_sections:
+            verse_lines = verse_sections[0]
+            # Find a good line to base the chorus on
+            for line in verse_lines:
+                if line and not line.startswith("[") and len(line.split()) >= 3:
+                    chorus_section = self.create_chorus(line)
+                    break
+                    
+            if not chorus_section:
+                chorus_section = ["[Chorus]", "We're living in the moment", "Feeling so alive"]
+                
+        # Rebuild the lyrics with proper structure
+        structured_lines = []
+        
+        # Add first verse
+        if verse_sections:
+            structured_lines.extend(verse_sections[0])
+            structured_lines.append("")  # Empty line for spacing
+            
+        # Add chorus
+        if chorus_section:
+            structured_lines.extend(chorus_section)
+            structured_lines.append("")  # Empty line for spacing
+            
+        # Add second verse if available
+        if len(verse_sections) > 1:
+            structured_lines.extend(verse_sections[1])
+            structured_lines.append("")  # Empty line for spacing
+            
+            # Repeat chorus
+            if chorus_section:
+                structured_lines.extend(chorus_section)
+                structured_lines.append("")  # Empty line for spacing
+                
+        # Add bridge if requested and we have enough content
+        if add_bridge and len(structured_lines) > 10:
+            bridge = self.create_bridge()
+            structured_lines.extend(bridge)
+            structured_lines.append("")  # Empty line for spacing
+            
+            # Final chorus
+            if chorus_section:
+                structured_lines.extend(chorus_section)
+                
+        # If we only have one verse and no second verse, add the chorus again
+        elif len(verse_sections) <= 1 and chorus_section:
+            structured_lines.extend(chorus_section)
+            
+        return "\n".join(structured_lines)

requirements.txt

@@ -0,0 +1,4 @@
+transformers>=4.30.0
+gradio==5.1.0
+torch>=2.0.0
+accelerate>=0.20.0

runtime.txt

@@ -0,0 +1 @@
+python-3.10