.

README.md

@@ -12,3 +12,83 @@ short_description: create this first space for getting familiar with space
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Music Genre Classifier + Lyric Stylist 🎵
+
+A powerful web application that combines music genre classification with AI-powered lyric generation. This tool can analyze both audio files and text lyrics to determine the genre, then generate new lyrics in that style or transform existing lyrics into different genres.
+
+## Features
+
+- **Dual Input Support**: 
+  - Audio file analysis for genre detection
+  - Text-based lyrics analysis
+- **Genre Classification**: 
+  - Accurate genre detection using state-of-the-art models
+  - Supports multiple popular music genres
+- **Lyric Generation**:
+  - Genre-aware lyric generation
+  - Theme-based content creation
+  - Multiple generation options (temperature, length, versions)
+- **Style Transfer**:
+  - Transform existing lyrics into different genres
+  - Preserve core message while adapting style
+
+## Installation
+
+1. Clone the repository:
+```bash
+git clone [your-repo-url]
+cd music-genre-classifier-lyric-stylist
+```
+
+2. Create a virtual environment (recommended):
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+3. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+1. Start the application:
+```bash
+python app.py
+```
+
+2. Open your web browser and navigate to the provided URL (typically http://localhost:7860)
+
+3. Choose your input method:
+   - Upload an audio file
+   - Enter lyrics text
+
+4. Adjust generation parameters:
+   - Temperature (controls randomness)
+   - Maximum length
+   - Number of versions
+
+5. Click "Detect Genre & Generate Lyrics" or use the "Style Transfer" tab for existing lyrics
+
+## Models Used
+
+- **Genre Classification**:
+  - Audio: `anton-l/wav2vec2-base-superb-gc`
+  - Text: `facebook/bart-large-mnli` (Zero-shot classification)
+- **Lyric Generation**: `gpt2-medium`
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Acknowledgments
+
+- Hugging Face for providing the pre-trained models
+- Gradio for the web interface framework
+- The open-source community for various audio processing libraries

requirements.txt

@@ -1,4 +1,9 @@
-gradio
-transformers
-torch
-soundfile
+gradio==4.12.0
+transformers==4.36.2
+torch==2.1.2
+torchaudio==2.1.2
+numpy==1.26.2
+datasets==2.15.0
+soundfile==0.12.1
+librosa==0.10.1
+python-dotenv==1.0.0

src/classifier.py

@@ -0,0 +1,90 @@
+import torch
+import torchaudio
+import librosa
+import numpy as np
+from transformers import pipeline
+from typing import Union, Tuple, List
+
+class MusicGenreClassifier:
+    def __init__(self):
+        # Initialize both audio and text classification pipelines
+        self.text_classifier = pipeline(
+            "zero-shot-classification",
+            model="facebook/bart-large-mnli"
+        )
+        
+        # For audio classification, we'll use a pre-trained model
+        self.audio_classifier = pipeline(
+            "audio-classification",
+            model="anton-l/wav2vec2-base-superb-gc"
+        )
+        
+        self.genres = [
+            "rock", "pop", "hip hop", "country", "jazz",
+            "classical", "electronic", "blues", "reggae", "metal"
+        ]
+    
+    def process_audio(self, audio_path: str) -> torch.Tensor:
+        """Process audio file to match model requirements."""
+        try:
+            # Load audio using librosa (handles more formats)
+            waveform, sample_rate = librosa.load(audio_path, sr=16000)
+            return torch.from_numpy(waveform)
+        except Exception as e:
+            raise ValueError(f"Error processing audio file: {str(e)}")
+
+    def classify_audio(self, audio_path: str) -> Tuple[str, float]:
+        """Classify genre from audio file."""
+        try:
+            waveform = self.process_audio(audio_path)
+            predictions = self.audio_classifier(waveform)
+            # Get the top prediction
+            top_pred = max(predictions, key=lambda x: x['score'])
+            return top_pred['label'], top_pred['score']
+        except Exception as e:
+            raise ValueError(f"Audio classification failed: {str(e)}")
+
+    def classify_text(self, lyrics: str) -> Tuple[str, float]:
+        """Classify genre from lyrics text."""
+        try:
+            # Prepare the hypothesis template for zero-shot classification
+            hypothesis_template = "This text contains {} music lyrics."
+            
+            result = self.text_classifier(
+                lyrics,
+                candidate_labels=self.genres,
+                hypothesis_template=hypothesis_template
+            )
+            
+            return result['labels'][0], result['scores'][0]
+        except Exception as e:
+            raise ValueError(f"Text classification failed: {str(e)}")
+
+    def predict(self, input_data: str, input_type: str = None) -> dict:
+        """
+        Main prediction method that handles both audio and text inputs.
+        
+        Args:
+            input_data: Path to audio file or lyrics text
+            input_type: Optional, 'audio' or 'text'. If None, will try to auto-detect
+            
+        Returns:
+            dict containing predicted genre and confidence score
+        """
+        # Try to auto-detect input type if not specified
+        if input_type is None:
+            input_type = 'audio' if input_data.lower().endswith(('.mp3', '.wav', '.ogg', '.flac')) else 'text'
+        
+        try:
+            if input_type == 'audio':
+                genre, confidence = self.classify_audio(input_data)
+            else:
+                genre, confidence = self.classify_text(input_data)
+                
+            return {
+                'genre': genre,
+                'confidence': float(confidence),
+                'input_type': input_type
+            }
+        except Exception as e:
+            raise ValueError(f"Prediction failed: {str(e)}") 

src/lyric_generator.py

@@ -0,0 +1,129 @@
+from transformers import pipeline
+from typing import Dict, List, Optional
+
+class LyricGenerator:
+    def __init__(self, model_name: str = "gpt2-medium"):
+        """
+        Initialize the lyric generator with a specified language model.
+        
+        Args:
+            model_name: The name of the pre-trained model to use
+        """
+        self.generator = pipeline(
+            "text-generation",
+            model=model_name,
+            device=0 if pipeline.device.type == "cuda" else -1
+        )
+        
+        # Genre-specific prompts to guide generation
+        self.genre_prompts = {
+            "rock": "Write energetic rock lyrics about",
+            "pop": "Create catchy pop lyrics about",
+            "hip hop": "Write hip hop verses about",
+            "country": "Write country music lyrics about",
+            "jazz": "Compose smooth jazz lyrics about",
+            "classical": "Write classical music lyrics about",
+            "electronic": "Create electronic dance music lyrics about",
+            "blues": "Write soulful blues lyrics about",
+            "reggae": "Write laid-back reggae lyrics about",
+            "metal": "Write intense metal lyrics about"
+        }
+        
+    def generate_lyrics(
+        self,
+        genre: str,
+        theme: str,
+        max_length: int = 200,
+        num_return_sequences: int = 1,
+        temperature: float = 0.9,
+        top_p: float = 0.9,
+        top_k: int = 50
+    ) -> List[str]:
+        """
+        Generate lyrics based on genre and theme.
+        
+        Args:
+            genre: The music genre to generate lyrics for
+            theme: The theme or topic for the lyrics
+            max_length: Maximum length of generated text
+            num_return_sequences: Number of different lyrics to generate
+            temperature: Controls randomness (higher = more random)
+            top_p: Nucleus sampling parameter
+            top_k: Top-k sampling parameter
+            
+        Returns:
+            List of generated lyrics
+        """
+        try:
+            # Get genre-specific prompt or use default
+            genre = genre.lower()
+            base_prompt = self.genre_prompts.get(
+                genre,
+                "Write song lyrics about"
+            )
+            
+            # Construct full prompt
+            prompt = f"{base_prompt} {theme}:\n\n"
+            
+            # Generate lyrics
+            outputs = self.generator(
+                prompt,
+                max_length=max_length,
+                num_return_sequences=num_return_sequences,
+                temperature=temperature,
+                top_p=top_p,
+                top_k=top_k,
+                do_sample=True,
+                pad_token_id=50256  # GPT-2's pad token ID
+            )
+            
+            # Process and clean up the generated texts
+            generated_lyrics = []
+            for output in outputs:
+                # Remove the prompt from the generated text
+                lyrics = output['generated_text'][len(prompt):].strip()
+                # Basic cleanup
+                lyrics = lyrics.replace('<|endoftext|>', '').strip()
+                generated_lyrics.append(lyrics)
+            
+            return generated_lyrics
+            
+        except Exception as e:
+            raise ValueError(f"Lyric generation failed: {str(e)}")
+    
+    def style_transfer(
+        self,
+        original_lyrics: str,
+        target_genre: str,
+        temperature: float = 0.9
+    ) -> str:
+        """
+        Attempt to transfer the style of existing lyrics to a target genre.
+        
+        Args:
+            original_lyrics: The original lyrics to restyle
+            target_genre: The target genre for the style transfer
+            temperature: Controls randomness of generation
+            
+        Returns:
+            Restyled lyrics in the target genre
+        """
+        try:
+            prompt = f"Rewrite these lyrics in {target_genre} style:\n\n{original_lyrics}\n\nNew version:\n"
+            
+            output = self.generator(
+                prompt,
+                max_length=len(prompt) + 200,
+                temperature=temperature,
+                top_p=0.9,
+                do_sample=True,
+                num_return_sequences=1
+            )[0]
+            
+            # Extract the new version only
+            generated_text = output['generated_text']
+            new_lyrics = generated_text.split("New version:\n")[-1].strip()
+            return new_lyrics
+            
+        except Exception as e:
+            raise ValueError(f"Style transfer failed: {str(e)}")