Add initial implementation of AnalysisGNN Gradio app with model integration and requirements

.gitignore

@@ -0,0 +1,215 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# AnalysisGNN artifacts
+artifacts/
+outputs/
+
+# Gradio cache
+gradio_cached_examples/
+flagged/

README.md

@@ -1,13 +1,101 @@
 ---
-title: Analysisgnn
-emoji: 🌍
+title: AnalysisGNN Music Analysis
+emoji: 🎵
 colorFrom: red
 colorTo: pink
 sdk: gradio
 sdk_version: 5.49.1
 app_file: app.py
 pinned: false
+license: mit
 short_description: Inference for the AnalysisGNN score analysis model
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AnalysisGNN Gradio Interface
+
+A Gradio web interface for [AnalysisGNN](https://github.com/manoskary/analysisGNN), a unified music analysis model using Graph Neural Networks.
+
+## Features
+
+- 🎼 **MusicXML Upload**: Upload and analyze musical scores in MusicXML format
+- 🎨 **Score Visualization**: Automatic rendering of uploaded scores to images
+- 📊 **Multi-task Analysis**: Perform various music analysis tasks:
+  - Cadence Detection
+  - Key Analysis (Local & Tonalized)
+  - Harmonic Analysis (Chord Quality, Root, Bass, Inversion)
+  - Roman Numeral Analysis
+  - Phrase & Section Segmentation
+- 📈 **Results Table**: View analysis results in an interactive table
+- 💾 **Export Results**: Download analysis results as CSV
+
+## Quick Start
+
+### Local Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/manoskary/analysisgnn-gradio.git
+cd analysisgnn-gradio
+
+# Create a virtual environment (recommended)
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the app
+python app.py
+```
+
+The app will be available at `http://localhost:7860`
+
+### Hugging Face Spaces
+
+This app is designed to run on Hugging Face Spaces. Simply deploy it as a Gradio Space.
+
+## Usage
+
+1. **Upload a MusicXML file** using the file upload button
+2. **Select analysis tasks** you want to perform (cadence, key, harmony, etc.)
+3. **Click "Analyze Score"** to run the inference
+4. **View results**:
+   - Score visualization (rendered image)
+   - Analysis results table (note-level predictions)
+5. **Download results** as CSV if needed
+
+## Model
+
+The app uses a pre-trained AnalysisGNN model automatically downloaded from Weights & Biases. The model is cached in the `./artifacts/` folder to avoid re-downloading.
+
+## Dependencies
+
+- `analysisgnn`: Core music analysis library
+- `gradio`: Web interface framework
+- `partitura`: Music processing library
+- `torch`: Deep learning framework
+- `pandas`: Data manipulation
+- See `requirements.txt` for complete list
+
+## Citation
+
+If you use this interface or AnalysisGNN in your research, please cite:
+
+```bibtex
+@inproceedings{karystinaios2024analysisgnn,
+    title={AnalysisGNN: A Unified Music Analysis Model with Graph Neural Networks},
+    author={Karystinaios, Emmanouil and Hentschel, Johannes and Neuwirth, Markus and Widmer, Gerhard},
+    booktitle={International Symposium on Computer Music Multidisciplinary Research (CMMR)},
+    year={2025}
+}
+```
+
+## License
+
+MIT License - See the [AnalysisGNN repository](https://github.com/manoskary/analysisGNN) for more details.
+
+## Acknowledgments
+
+- Built with [Gradio](https://gradio.app/)
+- Powered by [AnalysisGNN](https://github.com/manoskary/analysisGNN)
+- Music processing with [Partitura](https://github.com/CPJKU/partitura)

app.py

@@ -0,0 +1,488 @@
+#!/usr/bin/env python3
+"""
+AnalysisGNN Gradio App
+
+A Gradio interface for AnalysisGNN music analysis.
+Users can upload MusicXML scores, run the model, and view results.
+"""
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import os
+import tempfile
+import torch
+from pathlib import Path
+from typing import Tuple, Optional, Dict
+import traceback
+import warnings
+
+# Suppress warnings for cleaner output
+warnings.filterwarnings('ignore')
+
+# Import partitura and AnalysisGNN
+import partitura as pt
+from analysisgnn.models.analysis import ContinualAnalysisGNN
+from analysisgnn.utils.chord_representations import available_representations
+
+# Global model variable
+MODEL = None
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+print(f"Using device: {DEVICE}")
+if torch.cuda.is_available():
+    print(f"CUDA device: {torch.cuda.get_device_name(0)}")
+
+
+def download_wandb_checkpoint(artifact_path: str = "melkisedeath/AnalysisGNN/model-uvj2ddun:v1") -> str:
+    """Download checkpoint from Weights & Biases, or use cached version if available."""
+    # Create artifacts directory structure
+    artifacts_dir = "checkpoint"
+    os.makedirs(artifacts_dir, exist_ok=True)
+    
+    # Check if checkpoint already exists directly in artifacts/models
+    checkpoint_path = os.path.join(artifacts_dir, "model.ckpt")
+    if os.path.exists(checkpoint_path):
+        print(f"Using cached checkpoint: {checkpoint_path}")
+        return checkpoint_path
+    
+    # Check for any .ckpt file in the artifacts/models directory
+    if os.path.exists(artifacts_dir):
+        for fname in os.listdir(artifacts_dir):
+            if fname.endswith('.ckpt'):
+                checkpoint_path = os.path.join(artifacts_dir, fname)
+                print(f"Using cached checkpoint: {checkpoint_path}")
+                return checkpoint_path
+    
+    # Check artifact-specific subdirectory
+    artifact_dir = os.path.join(artifacts_dir, os.path.basename(artifact_path))
+    checkpoint_path = os.path.join(artifact_dir, "model.ckpt")
+    if os.path.exists(checkpoint_path):
+        print(f"Using cached checkpoint: {checkpoint_path}")
+        return checkpoint_path
+    
+    # Only import and use wandb if checkpoint is not cached
+    import wandb
+    print(f"Downloading checkpoint from W&B: {artifact_path}")
+    
+    # Initialize wandb in offline mode to avoid creating online runs
+    run = wandb.init(mode="offline")
+    try:
+        artifact = run.use_artifact(artifact_path, type='model')
+        artifact_dir = artifact.download(root=artifacts_dir)
+    finally:
+        wandb.finish()
+    
+    # Find the checkpoint file
+    checkpoint_path = os.path.join(artifact_dir, "model.ckpt")
+    if not os.path.exists(checkpoint_path):
+        for fname in os.listdir(artifact_dir):
+            if fname.endswith('.ckpt'):
+                checkpoint_path = os.path.join(artifact_dir, fname)
+                break
+    
+    return checkpoint_path
+
+
+def load_model() -> ContinualAnalysisGNN:
+    """Load the AnalysisGNN model."""
+    global MODEL
+    
+    if MODEL is None:
+        checkpoint_path = download_wandb_checkpoint()
+        print(f"Loading model from: {checkpoint_path}")
+        MODEL = ContinualAnalysisGNN.load_from_checkpoint(
+            checkpoint_path,
+            map_location=DEVICE
+        )
+        MODEL.eval()
+        MODEL.to(DEVICE)
+        print("Model loaded successfully!")
+    return MODEL
+
+
+def render_score_to_image(score: pt.score.Score, output_path: str) -> Optional[str]:
+    """
+    Render score to image using partitura.
+    
+    Parameters
+    ----------
+    score : pt.score.Score
+        The score to render
+    output_path : str
+        Path to save the rendered image
+        
+    Returns
+    -------
+    str or None
+        Path to the rendered image, or None if rendering failed
+    """
+    try:
+        # Try to render to PNG using partitura
+        pt.render(score, fmt="png", out=output_path)
+        if os.path.exists(output_path):
+            return output_path
+    except Exception as e:
+        print(f"Error rendering score to PNG: {e}")
+    
+    # If PNG rendering failed, try PDF
+    try:
+        pdf_path = output_path.replace('.png', '.pdf')
+        pt.render(score, fmt="pdf", out=pdf_path)
+        if os.path.exists(pdf_path):
+            # Convert PDF to PNG if possible
+            try:
+                from pdf2image import convert_from_path
+                images = convert_from_path(pdf_path)
+                if images:
+                    images[0].save(output_path, 'PNG')
+                    return output_path
+            except (ImportError, Exception) as e:
+                # If conversion fails, return the PDF path
+                print(f"PDF to PNG conversion failed: {e}")
+                return pdf_path
+    except Exception as e:
+        print(f"Error rendering score to PDF: {e}")
+    
+    return None
+
+
+def predict_analysis(
+    model: ContinualAnalysisGNN,
+    score: pt.score.Score,
+    tasks: list
+) -> Dict[str, np.ndarray]:
+    """
+    Perform music analysis prediction.
+    
+    Parameters
+    ----------
+    model : ContinualAnalysisGNN
+        The model to use for prediction
+    score : pt.score.Score
+        The score to analyze
+    tasks : list
+        List of analysis tasks to perform
+        
+    Returns
+    -------
+    dict
+        Dictionary mapping task names to predictions and confidence scores
+    """
+    with torch.no_grad():
+        # Get predictions from model
+        predictions = model.predict(score)
+    
+    # Decode predictions
+    decoded_predictions = {}
+    for task in tasks:
+        if task in predictions:
+            pred_tensor = predictions[task]
+            if len(pred_tensor.shape) > 1:
+                # Get confidence scores (probabilities)
+                pred_probs = torch.softmax(pred_tensor, dim=-1)
+                pred_onehot = torch.argmax(pred_tensor, dim=-1)
+                # Get confidence for the predicted class
+                confidence = torch.max(pred_probs, dim=-1)[0]
+                
+                # Store confidence scores
+                decoded_predictions[f"{task}_confidence"] = confidence.cpu().numpy()
+            else:
+                pred_onehot = pred_tensor
+            
+            # Decode using available representations
+            if task in available_representations:
+                try:
+                    decoded = available_representations[task].decode(
+                        pred_onehot.reshape(-1, 1)
+                    )
+                    # Convert to numpy array if it's a list
+                    if isinstance(decoded, list):
+                        decoded_predictions[task] = np.array(decoded).flatten()
+                    else:
+                        decoded_predictions[task] = decoded.flatten()
+                except (IndexError, ValueError) as e:
+                    print(f"Warning: Error decoding {task} predictions: {e}")
+                    # Fallback to raw indices
+                    decoded_predictions[task] = pred_onehot.cpu().numpy()
+            else:
+                decoded_predictions[task] = pred_onehot.cpu().numpy()
+    
+    # Add timing information
+    try:
+        if "onset" in predictions:
+            decoded_predictions["onset_beat"] = predictions["onset"].cpu().numpy()
+        else:
+            decoded_predictions["onset_beat"] = score.note_array()["onset_beat"]
+    except (AttributeError, KeyError, IndexError) as e:
+        print(f"Warning: Could not add onset timing: {e}")
+    
+    try:
+        if "s_measure" in predictions:
+            decoded_predictions["measure"] = predictions["s_measure"].cpu().numpy()
+        else:
+            decoded_predictions["measure"] = score[0].measure_number_map(score.note_array()["onset_div"])
+    except (AttributeError, KeyError, IndexError) as e:
+        print(f"Warning: Could not add measure information: {e}")
+    
+    return decoded_predictions
+
+
+def process_musicxml(
+    musicxml_file,
+    selected_tasks: list
+) -> Tuple[Optional[str], Optional[pd.DataFrame], str]:
+    """
+    Process a MusicXML file and return visualization and analysis results.
+    
+    Parameters
+    ----------
+    musicxml_file : file
+        Uploaded MusicXML file
+    selected_tasks : list
+        List of selected analysis tasks
+        
+    Returns
+    -------
+    tuple
+        (image_path, dataframe, status_message)
+    """
+    if musicxml_file is None:
+        return None, None, "Please upload a MusicXML file."
+    
+    if not selected_tasks:
+        return None, None, "Please select at least one analysis task."
+    
+    try:
+        # Load the model
+        status_msg = "Loading model..."
+        print(status_msg)
+        model = load_model()
+        
+        # Load the score
+        status_msg = "Loading score..."
+        print(status_msg)
+        score = pt.load_musicxml(musicxml_file.name)
+        
+        # Render score to image
+        status_msg = "Rendering score..."
+        print(status_msg)
+        with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp_img:
+            img_path = tmp_img.name
+        
+        rendered_path = render_score_to_image(score, img_path)
+        if rendered_path is None:
+            print("Note: Score rendering failed. This requires MuseScore or LilyPond to be installed.")
+        
+        # Perform analysis
+        status_msg = "Running analysis..."
+        print(status_msg)
+        predictions = predict_analysis(model, score, selected_tasks)
+        
+        # Create DataFrame
+        if predictions:
+            df = pd.DataFrame(predictions)
+            
+            # Add note/event IDs
+            if 'note_id' not in df.columns:
+                df.insert(0, 'note_id', range(len(df)))
+            
+            # Reorder columns to have timing info first, then predictions, then confidence
+            timing_cols = [col for col in ['note_id', 'onset_beat', 'measure'] if col in df.columns]
+            confidence_cols = [col for col in df.columns if col.endswith('_confidence')]
+            prediction_cols = [col for col in df.columns if col not in timing_cols and col not in confidence_cols]
+            
+            # Interleave predictions with their confidence scores
+            ordered_cols = timing_cols.copy()
+            for pred_col in prediction_cols:
+                ordered_cols.append(pred_col)
+                conf_col = f"{pred_col}_confidence"
+                if conf_col in confidence_cols:
+                    ordered_cols.append(conf_col)
+            
+            df = df[ordered_cols]
+            
+            status_msg = f"✓ Analysis complete! Analyzed {len(df)} notes with {len(selected_tasks)} task(s)."
+        else:
+            df = pd.DataFrame()
+            status_msg = "⚠ Analysis returned no predictions."
+        
+        return rendered_path, df, status_msg
+        
+    except Exception as e:
+        error_msg = f"Error processing file: {str(e)}\n\n{traceback.format_exc()}"
+        print(error_msg)
+        return None, None, error_msg
+
+
+# Define available tasks
+AVAILABLE_TASKS = {
+    "cadence": "Cadence Detection",
+    "localkey": "Local Key",
+    "tonkey": "Tonalized Key",
+    "quality": "Chord Quality",
+    "root": "Chord Root",
+    "bass": "Bass Note",
+    "inversion": "Chord Inversion",
+    "degree1": "Primary Degree",
+    "degree2": "Secondary Degree",
+    "romanNumeral": "Roman Numeral Analysis",
+    "phrase": "Phrase Segmentation",
+    "section": "Section Detection",
+}
+
+# Create Gradio interface
+with gr.Blocks(title="AnalysisGNN Music Analysis", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎵 AnalysisGNN Music Analysis
+    
+    Upload a MusicXML score to perform automatic music analysis using Graph Neural Networks.
+    
+    **Supported Analysis Tasks:**
+    - Cadence Detection
+    - Key Analysis (Local & Tonalized)
+    - Harmonic Analysis (Chords, Inversions, Roman Numerals)
+    - Phrase & Section Segmentation
+    
+    **Model:** Pre-trained AnalysisGNN from [manoskary/analysisGNN](https://github.com/manoskary/analysisGNN)
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Input section
+            gr.Markdown("### 📁 Input")
+            file_input = gr.File(
+                label="Upload MusicXML Score",
+                file_types=[".musicxml", ".xml", ".mxl"],
+                type="filepath"
+            )
+            
+            task_selector = gr.CheckboxGroup(
+                choices=list(AVAILABLE_TASKS.values()),
+                value=["Cadence Detection", "Local Key", "Roman Numeral Analysis"],
+                label="Select Analysis Tasks",
+                info="Choose which tasks to perform"
+            )
+            
+            analyze_btn = gr.Button("🎼 Analyze Score", variant="primary", size="lg")
+            
+            gr.Markdown("---")
+            example_btn = gr.Button("🎵 Try Example (Mozart K.158)", size="sm")
+            
+        with gr.Column(scale=2):
+            # Output section
+            gr.Markdown("### 📊 Results")
+            status_output = gr.Textbox(
+                label="Status",
+                lines=2,
+                interactive=False
+            )
+    
+    with gr.Row():
+        with gr.Column():
+            # Score visualization
+            gr.Markdown("### 🎼 Score Visualization")
+            image_output = gr.Image(
+                label="Rendered Score",
+                type="filepath"
+            )
+    
+    with gr.Row():
+        with gr.Column():
+            # Analysis results table
+            gr.Markdown("### 📈 Analysis Results")
+            table_output = gr.Dataframe(
+                label="Analysis Output",
+                wrap=True,
+                interactive=False
+            )
+            
+            download_btn = gr.Button("💾 Download Results as CSV")
+            csv_output = gr.File(label="Download CSV")
+    
+    # Example section
+    gr.Markdown("""
+    ### 💡 Tips & Information
+    
+    **Getting Started:**
+    - Click "Try Example" to load a Mozart quartet, or upload your own MusicXML file
+    - Select the analysis tasks you're interested in
+    - Click "Analyze Score" to run the model
+    
+    **Analysis Output:**
+    The table shows note-level predictions for all selected tasks:
+    - **Onset & Measure**: Timing information
+    - **Keys**: Detected key areas (local and tonalized)
+    - **Chords**: Harmonic analysis with Roman numerals
+    - **Cadences**: Identified cadence points and types
+    
+    **Score Visualization:**
+    Requires MuseScore or LilyPond for rendering. If unavailable, analysis will still work.
+    """)
+    
+    # Event handlers
+    def analyze_wrapper(file, tasks_selected):
+        # Convert task names back to internal names
+        task_mapping = {v: k for k, v in AVAILABLE_TASKS.items()}
+        selected_task_keys = [task_mapping[t] for t in tasks_selected if t in task_mapping]
+        return process_musicxml(file, selected_task_keys)
+    
+    def load_example():
+        """Load example Mozart score."""
+        import urllib.request
+        
+        url = "https://raw.githubusercontent.com/manoskary/humdrum-mozart-quartets/refs/heads/master/musicxml/k158-01.musicxml"
+        
+        # Create artifacts directory if it doesn't exist
+        os.makedirs("./artifacts", exist_ok=True)
+        
+        example_path = "./artifacts/k158-01.musicxml"
+        
+        if not os.path.exists(example_path):
+            try:
+                print(f"Downloading example score from: {url}")
+                urllib.request.urlretrieve(url, example_path)
+                print(f"Example score saved to: {example_path}")
+            except Exception as e:
+                return None, f"Error downloading example: {e}"
+        
+        return example_path, "Example loaded! Click 'Analyze Score' to proceed."
+    
+    analyze_btn.click(
+        fn=analyze_wrapper,
+        inputs=[file_input, task_selector],
+        outputs=[image_output, table_output, status_output]
+    )
+    
+    example_btn.click(
+        fn=load_example,
+        outputs=[file_input, status_output]
+    )
+    
+    def save_csv(df):
+        if df is None or len(df) == 0:
+            return None
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp:
+            df.to_csv(tmp.name, index=False)
+            return tmp.name
+    
+    download_btn.click(
+        fn=save_csv,
+        inputs=[table_output],
+        outputs=[csv_output]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    # Pre-load the model at startup for efficiency
+    print("=" * 50)
+    print("Initializing AnalysisGNN app...")
+    print("=" * 50)
+    print("Pre-loading model at startup...")
+    load_model()
+    print("✓ Model loaded successfully!")
+    
+    print("=" * 50)
+    print("Starting Gradio interface...")
+    print("=" * 50)
+    demo.launch()

checkpoint/model.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53d106038fea6a5ab3d4c0a19617736dff5f0299deffaf240ebd484c11f91c67
+size 126890023

requirements.txt

@@ -0,0 +1,38 @@
+# PyTorch (install first, required by other packages)
+torch>=2.0.0
+torchvision>=0.15.0
+
+# PyTorch extensions (require torch to be installed)
+pytorch-lightning>=2.0.0
+torch-geometric>=2.3.0
+torch-scatter>=2.1.0
+torch-sparse>=0.6.0
+
+# Data processing
+numpy>=1.21.0
+pandas>=1.5.0
+
+# Music processing
+partitura>=1.4.0
+music21>=8.0.0
+
+# Gradio and Spaces
+gradio>=4.0.0
+
+# Wandb for model loading
+wandb>=0.13.0
+
+# PDF rendering and image processing
+reportlab>=4.0.0
+pdf2image>=1.16.0
+Pillow>=9.0.0
+
+# ML utilities
+scikit-learn>=1.1.0
+torchmetrics>=0.11.0
+
+# Other utilities
+tqdm>=4.64.0
+
+# Core AnalysisGNN dependency (install last, after all dependencies)
+git+https://github.com/manoskary/analysisGNN.git