.

README.md

@@ -1,109 +1,45 @@
 ---
-title: Fyp Start Space
-emoji: 🏆
-colorFrom: purple
-colorTo: green
+title: Music Classification with MIT AST
+emoji: 🎵
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.5.0
+sdk_version: 4.12.0
 app_file: app.py
 pinned: false
 license: mit
-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 Classification with MIT's AST Model 🎵
 
-# 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.
+This Hugging Face Space demonstrates audio classification using MIT's Audio Spectrogram Transformer (AST) model. The model can identify various types of music, instruments, and sounds in audio files.
 
 ## 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 (supports .mp3, .wav, .ogg, .flac)
-   - 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: `mit/ast-finetuned-audioset-10-10-0.4593` (MIT's Audio Spectrogram Transformer)
-  - Text: `facebook/bart-large-mnli` (Zero-shot classification)
-- **Lyric Generation**: `gpt2-medium`
+- Simple, user-friendly interface
+- Support for multiple audio formats (WAV, MP3, OGG, FLAC)
+- Top-5 predictions with confidence scores
+- Real-time processing
 
-## Supported Genres
+## How to Use
 
-The system supports classification and generation for the following genres:
-- Rock
-- Pop
-- Hip Hop
-- Country
-- Jazz
-- Classical
-- Electronic
-- Blues
-- Reggae
-- Metal
+1. Click the "Upload Music File" button or drag and drop an audio file
+2. Wait a few seconds for the model to process the audio
+3. View the classification results with confidence scores
 
-## Contributing
+## Model Details
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+This app uses the `MIT/ast-finetuned-audioset-10-10-0.4593` model, which is trained on AudioSet and can recognize a wide variety of sounds and music styles. The model converts audio into spectrograms and uses a transformer architecture to classify the audio content.
 
-## License
+## Technical Notes
 
-This project is licensed under the MIT License - see the LICENSE file for details.
+- The model processes audio at 16kHz
+- Results show top 5 predictions with confidence scores
+- Processing is done on Hugging Face's infrastructure
+- No local installation required
 
-## Acknowledgments
+## Credits
 
-- MIT for the Audio Spectrogram Transformer model
-- Hugging Face for providing the pre-trained models
-- Gradio for the web interface framework
-- The open-source community for various audio processing libraries
+- Model: [MIT AST](https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593)
+- Interface: Gradio
+- Deployment: Hugging Face Spaces

requirements.txt

@@ -1,10 +1,7 @@
-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
-accelerate
+gradio>=4.12.0
+transformers>=4.36.2
+torch>=2.1.2
+torchaudio>=2.1.2
+numpy>=1.26.2
+accelerate>=0.25.0
+librosa>=0.10.1

src/classifier.py

@@ -1,148 +0,0 @@
-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):
-        try:
-            # Initialize both audio and text classification pipelines with auto device mapping
-            self.text_classifier = pipeline(
-                "zero-shot-classification",
-                model="facebook/bart-large-mnli",
-                device="cpu"
-            )
-            
-            # For audio classification, we'll use MIT's music classification model
-            self.audio_classifier = pipeline(
-                "audio-classification",
-                model="mit/ast-finetuned-audioset-10-10-0.4593",
-                device="cpu"
-            )
-        except Exception as e:
-            print(f"Warning: GPU initialization failed, falling back to CPU. Error: {str(e)}")
-            # Fall back to CPU if GPU initialization fails
-            self.text_classifier = pipeline(
-                "zero-shot-classification",
-                model="facebook/bart-large-mnli",
-                device="cpu"
-            )
-            
-            self.audio_classifier = pipeline(
-                "audio-classification",
-                model="mit/ast-finetuned-audioset-10-10-0.4593",
-                device="cpu"
-            )
-        
-        # Define standard genres for classification
-        self.genres = [
-            "rock", "pop", "hip hop", "country", "jazz",
-            "classical", "electronic", "blues", "reggae", "metal"
-        ]
-        
-        # Mapping from model output labels to our standard genres
-        self.label_mapping = {
-            "Music": "pop",  # Default mapping
-            "Rock music": "rock",
-            "Pop music": "pop",
-            "Hip hop music": "hip hop",
-            "Country": "country",
-            "Jazz": "jazz",
-            "Classical music": "classical",
-            "Electronic music": "electronic",
-            "Blues": "blues",
-            "Reggae": "reggae",
-            "Heavy metal": "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)
-            # Convert to torch tensor and ensure proper shape
-            waveform = torch.from_numpy(waveform).float()
-            if len(waveform.shape) == 1:
-                waveform = waveform.unsqueeze(0)
-            return waveform
-        except Exception as e:
-            raise ValueError(f"Error processing audio file: {str(e)}")
-
-    def map_label_to_genre(self, label: str) -> str:
-        """Map model output label to standard genre."""
-        return self.label_mapping.get(label, "pop")  # Default to pop if unknown
-
-    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, top_k=3)
-            
-            # Process predictions
-            if isinstance(predictions, list):
-                predictions = predictions[0]
-            
-            # Find the highest scoring music-related prediction
-            music_preds = [
-                (self.map_label_to_genre(p['label']), p['score'])
-                for p in predictions
-                if p['label'] in self.label_mapping
-            ]
-            
-            if not music_preds:
-                # If no music genres found, return default
-                return "pop", 0.5
-            
-            # Get the highest scoring genre
-            genre, score = max(music_preds, key=lambda x: x[1])
-            return genre, 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

@@ -1,144 +0,0 @@
-from transformers import pipeline
-import torch
-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
-        """
-        try:
-            # Try to use CUDA if available
-            if torch.cuda.is_available():
-                device = "cuda"
-            else:
-                device = "cpu"
-            
-            self.generator = pipeline(
-                "text-generation",
-                model=model_name,
-                device_map="auto"  # Let transformers handle device mapping
-            )
-        except Exception as e:
-            print(f"Warning: GPU initialization failed, falling back to CPU. Error: {str(e)}")
-            self.generator = pipeline(
-                "text-generation",
-                model=model_name,
-                device="cpu"
-            )
-        
-        # 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)}")