Restore example-based MuseMorphose deployment

README.md

@@ -8,20 +8,14 @@ sdk_version: 5.28.0
 python_version: '3.12'
 app_file: app.py
 license: cc-by-4.0
-short_description: Transform piano MIDI with rhythm and polyphony
+short_description: Explore MuseMorphose on preprocessed piano examples
 ---
 
 # MuseMorphose
 
-MuseMorphose transforms piano music using bar-level rhythmic intensity and polyphonicity controls. **Upload your own `.mid` or `.midi` file**, select up to four bars, adjust the controls, and download the generated MIDI. A compatible REMI event file can be uploaded from the advanced section instead. You can also try one of three built-in examples without uploading anything.
+This Space runs the released MuseMorphose checkpoint on three preprocessed pieces from the REMI Pop Piano Dataset. Choose an example and a range of up to four bars, adjust rhythmic intensity and polyphonicity, and download the reference and generated MIDI files. Inference can be slow on CPU.
 
-The official MuseMorphose project does not include a MIDI upload converter. This Space adds a compatibility adapter for ordinary **4/4 MIDI**. It merges all pitched tracks into one piano part, ignores drum tracks, quantizes notes and tempo to the released model vocabulary, and trims empty leading bars. Notes outside pitches 22–107 and excess notes in very dense bars are omitted; the output details report all omissions. Compatible chord markers are retained at their quantized positions; MIDI files without them use the model's unknown-chord token because this adapter does not infer harmony. The downloadable **Model input MIDI** shows the quantized piece sent to the model. This conversion is approximate and can differ from the unreleased training preprocessing. Inference can be slow on CPU.
-
-Select at most four bars per generation. To choose a later section of a MIDI file, change **Start bar** after uploading; bar 0 is the first bar containing pitched notes.
-
-## Advanced REMI input
-
-Upload a UTF-8 `.remi` or `.txt` file with one MuseMorphose vocabulary token per line, starting with `Bar_None`. A `.json` file may contain an array of those tokens, an `{"events": [...]}` object, or name/value event objects. See [example_511.remi](examples/example_511.remi) for a working input. Files are limited to 1 MB, 10,000 events, 256 bars, and 128 events per bar. Pickle uploads are not accepted.
+The model operates on REMI event tokens produced by the original preprocessing pipeline. The official release demonstrates generation from preprocessed dataset pieces; it does not provide an interface for arbitrary MIDI or REMI uploads. Converting a new MIDI into compatible tokens would require a separate preprocessing pipeline and is outside this model deployment.
 
 The upstream code is MIT licensed. The checkpoint and the REMI Pop Piano Dataset examples are CC BY 4.0; see [SOURCES.md](SOURCES.md) for attribution.
 

SOURCES.md

@@ -5,4 +5,4 @@
 - Three example REMI pieces: [REMI Pop Piano Dataset](https://doi.org/10.5281/zenodo.4782721) by Shih-Lun Wu, Wen-Yi Hsiao, and Yi-Hsuan Yang (CC BY 4.0). Archive SHA-256 `b3e38e03f2f979826f6b5dc700fcad2f9b5d19f837308c5050825e14cf043802`. The vocabulary is from the official MuseMorphose repository.
 - Paper: https://arxiv.org/abs/2105.04090.
 
-The official release provides generation from preprocessed REMI dataset pieces. It does not provide conversion of arbitrary uploaded MIDI files to its training representation. This endpoint adds an approximate MIDI-to-REMI compatibility adapter based on the released MuseMorphose vocabulary and event ordering, using `miditoolkit` to read MIDI. The adapter is our implementation; no code from the GPL-licensed [YatingMusic REMI repository](https://github.com/YatingMusic/remi) was copied. Advanced UTF-8 REMI event uploads and three official example pieces remain supported.
+The official release provides generation from preprocessed REMI dataset pieces. It does not provide an interface for arbitrary MIDI or REMI uploads. This Space wraps the released checkpoint and three dataset examples in a Gradio interface, with a four-bar generation limit for its CPU demo.

app.py

@@ -17,9 +17,7 @@ model_card = ModelCard(
 
 
 def process_fn(
-    midi_path,
     sample_name,
-    remi_path,
     start_bar,
     bars,
     rhythm_shift,
@@ -40,8 +38,6 @@ def process_fn(
                 top_p,
                 seed,
                 Path(tmp),
-                midi_path=midi_path,
-                remi_path=remi_path,
             )
             return (
                 outputs[0].move_resource_to_block_cache(reference),
@@ -53,30 +49,18 @@ def process_fn(
 
 
 with gr.Blocks(title="MuseMorphose", delete_cache=(3600, 86400)) as demo:
-    gr.Markdown("## Transform your own MIDI")
+    gr.Markdown("## MuseMorphose piano examples")
+    gr.Markdown(
+        "Choose a preprocessed piano example, adjust its rhythmic intensity or "
+        "polyphonicity, and generate a new MIDI performance."
+    )
     inputs = [
-        gr.File(
-            type="filepath",
-            file_types=[".mid", ".midi"],
-            label="Upload your MIDI (.mid or .midi)",
-            height=140,
-        ).set_info(
-            "Pitched tracks are merged into one piano part; drum tracks are ignored."
+        gr.Dropdown(
+            choices=list(EXAMPLES),
+            value="Piano example 511",
+            label="Preprocessed piano example",
         ),
     ]
-    with gr.Accordion("Advanced inputs: examples or REMI", open=False):
-        example_input = gr.Dropdown(
-            choices=list(EXAMPLES),
-            value=None,
-            label="Built-in example (optional)",
-        ).set_info("Used when no file is uploaded.")
-        remi_input = gr.File(
-            type="filepath",
-            file_types=[".remi", ".txt", ".json"],
-            label="Upload REMI events (optional)",
-            height=100,
-        ).set_info("Use a compatible UTF-8 MuseMorphose event list; no pickle files.")
-    inputs.extend([example_input, remi_input])
     inputs.extend(
         [
             gr.Number(value=0, minimum=0, maximum=9999, precision=0, label="Start bar"),
@@ -93,7 +77,7 @@ with gr.Blocks(title="MuseMorphose", delete_cache=(3600, 86400)) as demo:
         ]
     )
     outputs = [
-        gr.File(label="Model input MIDI", file_types=[".mid"]),
+        gr.File(label="Reference MIDI", file_types=[".mid"]),
         gr.File(label="Transformed MIDI", file_types=[".mid"]),
         gr.JSON(label="Generation details"),
     ]
@@ -106,6 +90,4 @@ with gr.Blocks(title="MuseMorphose", delete_cache=(3600, 86400)) as demo:
 
 
 if __name__ == "__main__":
-    demo.queue(default_concurrency_limit=1, max_size=8).launch(
-        show_error=True, max_file_size="10mb"
-    )
+    demo.queue(default_concurrency_limit=1, max_size=8).launch(show_error=True)

examples/example_511.remi

@@ -1,83 +0,0 @@
-Bar_None
-Beat_0
-Chord_N_N
-Tempo_119
-Note_Pitch_67
-Note_Velocity_58
-Note_Duration_1920
-Note_Pitch_64
-Note_Velocity_58
-Note_Duration_1920
-Note_Pitch_62
-Note_Velocity_56
-Note_Duration_1920
-Note_Pitch_59
-Note_Velocity_54
-Note_Duration_1920
-Beat_12
-Tempo_140
-Bar_None
-Beat_0
-Chord_D_m7
-Tempo_146
-Note_Pitch_81
-Note_Velocity_66
-Note_Duration_1920
-Note_Pitch_69
-Note_Velocity_60
-Note_Duration_1920
-Note_Pitch_65
-Note_Velocity_50
-Note_Duration_1920
-Note_Pitch_62
-Note_Velocity_56
-Note_Duration_1920
-Note_Pitch_60
-Note_Velocity_52
-Note_Duration_1920
-Beat_4
-Tempo_149
-Beat_8
-Tempo_143
-Beat_12
-Tempo_140
-Bar_None
-Beat_0
-Chord_E_m7
-Tempo_149
-Note_Pitch_67
-Note_Velocity_58
-Note_Duration_1920
-Note_Pitch_64
-Note_Velocity_54
-Note_Duration_1920
-Note_Pitch_62
-Note_Velocity_58
-Note_Duration_1920
-Note_Pitch_59
-Note_Velocity_56
-Note_Duration_1920
-Beat_4
-Tempo_143
-Beat_12
-Tempo_140
-Bar_None
-Beat_0
-Chord_D_m7
-Tempo_146
-Note_Pitch_81
-Note_Velocity_66
-Note_Duration_1920
-Note_Pitch_69
-Note_Velocity_62
-Note_Duration_1920
-Note_Pitch_65
-Note_Velocity_56
-Note_Duration_1920
-Note_Pitch_60
-Note_Velocity_52
-Note_Duration_1920
-Beat_4
-Tempo_143
-Beat_12
-Tempo_140

midi_adapter.py

@@ -1,244 +0,0 @@
-"""Convert ordinary 4/4 MIDI into the MuseMorphose checkpoint's REMI vocabulary.
-
-This is a compatibility adapter, not the unavailable MuseMorphose training
-preprocessor. It merges pitched tracks into one piano part and quantizes notes
-to the model's 16th-note grid and released vocabulary.
-"""
-
-from __future__ import annotations
-
-from collections import defaultdict
-from pathlib import Path
-
-import miditoolkit
-
-TICKS_PER_BEAT = 480
-GRID = 120
-TICKS_PER_BAR = 1920
-MAX_MIDI_BYTES = 10_000_000
-MAX_BARS = 256
-
-
-def _nearest(value: float, options: list[int]) -> int:
-    return min(options, key=lambda candidate: (abs(candidate - value), candidate))
-
-
-def _grid_tick(tick: int) -> int:
-    return max(0, ((tick + GRID // 2) // GRID) * GRID)
-
-
-def _numeric_vocab(event2idx: dict[str, int], prefix: str) -> list[int]:
-    return sorted(
-        int(token.removeprefix(prefix))
-        for token in event2idx
-        if token.startswith(prefix)
-    )
-
-
-def midi_to_events(path: str | Path, event2idx: dict[str, int]):
-    """Return bar offsets, REMI events, and conversion details for one MIDI."""
-    path = Path(path)
-    if path.suffix.lower() not in {".mid", ".midi"}:
-        raise ValueError("Upload a .mid or .midi file.")
-    if path.stat().st_size > MAX_MIDI_BYTES:
-        raise ValueError("MIDI files must be at most 10 MB.")
-    try:
-        midi = miditoolkit.MidiFile(str(path))
-    except Exception as exc:
-        raise ValueError(f"Could not read this MIDI file: {exc}") from exc
-    if midi.ticks_per_beat <= 0:
-        raise ValueError("The MIDI file has an invalid tick resolution.")
-    for signature in midi.time_signature_changes:
-        if (signature.numerator, signature.denominator) != (4, 4):
-            raise ValueError(
-                "MuseMorphose MIDI upload currently supports only 4/4 time."
-            )
-
-    pitches = _numeric_vocab(event2idx, "Note_Pitch_")
-    velocities = _numeric_vocab(event2idx, "Note_Velocity_")
-    durations = [
-        value for value in _numeric_vocab(event2idx, "Note_Duration_") if value > 0
-    ]
-    tempos = _numeric_vocab(event2idx, "Tempo_")
-    pitch_min, pitch_max = min(pitches), max(pitches)
-    scale = TICKS_PER_BEAT / midi.ticks_per_beat
-
-    pitched_tracks = [track for track in midi.instruments if not track.is_drum]
-    ignored_drum_tracks = sum(track.is_drum for track in midi.instruments)
-    if not pitched_tracks:
-        raise ValueError(
-            "The MIDI file contains no pitched notes; drum-only files are unsupported."
-        )
-
-    raw_notes = [note for track in pitched_tracks for note in track.notes]
-    if not raw_notes:
-        raise ValueError("The MIDI file contains no pitched notes.")
-    supported = []
-    omitted_pitch = 0
-    omitted_invalid = 0
-    for note in raw_notes:
-        if not pitch_min <= note.pitch <= pitch_max:
-            omitted_pitch += 1
-            continue
-        if note.end <= note.start:
-            omitted_invalid += 1
-            continue
-        start = _grid_tick(round(note.start * scale))
-        length = _nearest((note.end - note.start) * scale, durations)
-        supported.append(
-            (start, note.pitch, _nearest(note.velocity, velocities), length)
-        )
-    if not supported:
-        raise ValueError(
-            f"No supported piano notes remain (pitch range {pitch_min}–{pitch_max})."
-        )
-
-    leading_bars = min(note[0] for note in supported) // TICKS_PER_BAR
-    offset = leading_bars * TICKS_PER_BAR
-    unique_notes = {}
-    for start, pitch, velocity, duration in supported:
-        key = (start - offset, pitch)
-        candidate = (start - offset, pitch, velocity, duration)
-        previous = unique_notes.get(key)
-        if previous is None or (duration, velocity) > (previous[3], previous[2]):
-            unique_notes[key] = candidate
-    notes = sorted(unique_notes.values(), key=lambda item: (item[0], -item[1]))
-    n_bars = notes[-1][0] // TICKS_PER_BAR + 1
-    if n_bars > MAX_BARS:
-        raise ValueError(
-            f"The MIDI has more than {MAX_BARS} bars. Upload a shorter excerpt."
-        )
-
-    # Keep source tempo changes in beat time, then repeat the active tempo at
-    # each bar start so the excerpt is self-contained when users select bars.
-    raw_tempos = sorted(midi.tempo_changes, key=lambda change: change.time)
-    active_bpm = 120.0
-    tempo_at_step = {}
-    for change in raw_tempos:
-        tick = _grid_tick(round(change.time * scale))
-        if tick <= offset:
-            active_bpm = change.tempo
-        elif tick - offset < n_bars * TICKS_PER_BAR:
-            tempo_at_step[tick - offset] = change.tempo
-    tempo_at_step[0] = active_bpm
-    for bar in range(n_bars):
-        bar_start = bar * TICKS_PER_BAR
-        candidates = [position for position in tempo_at_step if position <= bar_start]
-        if candidates:
-            tempo_at_step[bar_start] = tempo_at_step[max(candidates)]
-
-    chord_at_step = {}
-    active_chord = "Chord_N_N"
-    for marker in sorted(midi.markers, key=lambda item: item.time):
-        label = marker.text
-        if label.startswith("Chord-"):
-            chord = "Chord_" + label.removeprefix("Chord-")
-        elif label.startswith("Chord_"):
-            chord = label
-        else:
-            continue
-        if chord in event2idx:
-            tick = _grid_tick(round(marker.time * scale))
-            if tick <= offset:
-                active_chord = chord
-            elif tick - offset < n_bars * TICKS_PER_BAR:
-                chord_at_step[tick - offset] = chord
-    chord_at_step[0] = active_chord
-    for bar in range(n_bars):
-        bar_start = bar * TICKS_PER_BAR
-        candidates = [position for position in chord_at_step if position <= bar_start]
-        if candidates:
-            chord_at_step[bar_start] = chord_at_step[max(candidates)]
-
-    notes_by_bar = defaultdict(list)
-    for note in notes:
-        notes_by_bar[note[0] // TICKS_PER_BAR].append(note)
-    dropped_for_density = 0
-    events = []
-    bar_positions = []
-
-    def build_bar(bar: int, bar_notes: list[tuple[int, int, int, int]]):
-        bar_start = bar * TICKS_PER_BAR
-        beat_notes = defaultdict(list)
-        for note in bar_notes:
-            beat_notes[(note[0] - bar_start) // GRID].append(note)
-        beat_tempos = {
-            (tick - bar_start) // GRID: _nearest(bpm, tempos)
-            for tick, bpm in tempo_at_step.items()
-            if bar_start <= tick < bar_start + TICKS_PER_BAR
-        }
-        beat_chords = {
-            (tick - bar_start) // GRID: chord
-            for tick, chord in chord_at_step.items()
-            if bar_start <= tick < bar_start + TICKS_PER_BAR
-        }
-        result = [{"name": "Bar", "value": None}]
-        for beat in sorted({0, *beat_notes, *beat_tempos, *beat_chords}):
-            result.append({"name": "Beat", "value": beat})
-            if beat in beat_chords:
-                result.append(
-                    {
-                        "name": "Chord",
-                        "value": beat_chords[beat].removeprefix("Chord_"),
-                    }
-                )
-            if beat in beat_tempos:
-                result.append({"name": "Tempo", "value": beat_tempos[beat]})
-            for _, pitch, velocity, duration in sorted(
-                beat_notes[beat], key=lambda note: -note[1]
-            ):
-                result.extend(
-                    (
-                        {"name": "Note_Pitch", "value": pitch},
-                        {"name": "Note_Velocity", "value": velocity},
-                        {"name": "Note_Duration", "value": duration},
-                    )
-                )
-        return result
-
-    for bar in range(n_bars):
-        selected = list(notes_by_bar[bar])
-        bar_events = build_bar(bar, selected)
-        if len(bar_events) > 128:
-            strongest = sorted(
-                selected,
-                key=lambda note: (note[2] * note[3], note[0], note[1]),
-                reverse=True,
-            )
-            low, high = 0, len(strongest)
-            while low < high:
-                keep = (low + high + 1) // 2
-                candidate = build_bar(bar, strongest[:keep])
-                if len(candidate) <= 128:
-                    low = keep
-                else:
-                    high = keep - 1
-            dropped_for_density += len(selected) - low
-            selected = strongest[:low]
-            bar_events = build_bar(bar, selected)
-        if len(bar_events) > 128:
-            raise ValueError(
-                f"Bar {bar + 1} is too dense for the 128-event encoder limit."
-            )
-        bar_positions.append(len(events))
-        events.extend(bar_events)
-
-    for position, event in enumerate(events, start=1):
-        token = f"{event['name']}_{event['value']}"
-        if token not in event2idx:
-            raise ValueError(
-                f"MIDI conversion produced an unsupported event at position {position}: {token}"
-            )
-    details = {
-        "source_tracks_merged": len(pitched_tracks),
-        "ignored_drum_tracks": ignored_drum_tracks,
-        "source_notes": len(raw_notes),
-        "encoded_notes": len(notes) - dropped_for_density,
-        "omitted_out_of_range_notes": omitted_pitch,
-        "omitted_invalid_notes": omitted_invalid,
-        "omitted_duplicate_notes": len(supported) - len(notes),
-        "omitted_for_density": dropped_for_density,
-        "trimmed_leading_bars": leading_bars,
-        "available_bars": n_bars,
-    }
-    return bar_positions, events, details

runtime.py

@@ -1,8 +1,7 @@
-"""Inference adapter for the official MuseMorphose checkpoint and REMI events."""
+"""Inference adapter for the official checkpoint and preprocessed REMI examples."""
 
 from __future__ import annotations
 
-import json
 import pickle
 import random
 import sys
@@ -16,7 +15,6 @@ import torch
 ROOT = Path(__file__).resolve().parent
 sys.path.insert(0, str(ROOT / "model"))  # Official model uses absolute sibling imports.
 
-from midi_adapter import midi_to_events
 from model.musemorphose import MuseMorphose
 from remi2midi import remi2midi
 
@@ -28,16 +26,6 @@ EXAMPLES = {
     "Piano example 1719": 1719,
     "Piano example 144": 144,
 }
-MAX_REMI_BYTES = 1_000_000
-EVENT_PREFIXES = (
-    "Note_Pitch_",
-    "Note_Velocity_",
-    "Note_Duration_",
-    "Beat_",
-    "Tempo_",
-    "Chord_",
-    "Bar_",
-)
 RHYTHM_BOUNDS = [0.2, 0.25, 0.32, 0.38, 0.44, 0.5, 0.63]
 POLYPHONY_BOUNDS = [2.63, 3.06, 3.50, 4.00, 4.63, 5.44, 6.44]
 
@@ -76,107 +64,6 @@ def _event_name(event):
     return f"{event['name']}_{event['value']}"
 
 
-def _parse_event(token):
-    for prefix in EVENT_PREFIXES:
-        if token.startswith(prefix):
-            value = token[len(prefix) :]
-            return {
-                "name": prefix[:-1],
-                "value": None if token == "Bar_None" else value,
-            }
-    raise ValueError(f"Unsupported REMI event: {token}")
-
-
-def load_uploaded_events(path, event2idx):
-    """Read text/JSON events without deserializing untrusted pickle files."""
-    path = Path(path)
-    if path.suffix.lower() not in {".remi", ".txt", ".json"}:
-        raise ValueError("Upload a .remi, .txt, or .json event file.")
-    if path.stat().st_size > MAX_REMI_BYTES:
-        raise ValueError("REMI files must be at most 1 MB.")
-    try:
-        content = path.read_text(encoding="utf-8-sig")
-    except UnicodeError as exc:
-        raise ValueError("The REMI file must use UTF-8 text.") from exc
-    if path.suffix.lower() == ".json":
-        try:
-            data = json.loads(content)
-        except json.JSONDecodeError as exc:
-            raise ValueError(f"Invalid JSON at line {exc.lineno}.") from exc
-        if isinstance(data, dict):
-            data = data.get("events")
-        if not isinstance(data, list):
-            raise ValueError(
-                'JSON must be an event list or an object with an "events" list.'
-            )
-        tokens = []
-        for item in data:
-            if isinstance(item, str):
-                tokens.append(item)
-            elif isinstance(item, dict) and isinstance(item.get("name"), str):
-                tokens.append(_event_name(item))
-            else:
-                raise TypeError(
-                    "Each JSON event must be a token string or name/value object."
-                )
-    else:
-        tokens = [line.strip() for line in content.splitlines() if line.strip()]
-    if not tokens or len(tokens) > 10_000:
-        raise ValueError("The REMI file must contain 1–10,000 events.")
-    if tokens[0] != "Bar_None":
-        raise ValueError("The first event must be Bar_None.")
-    for position, token in enumerate(tokens, start=1):
-        if (
-            not isinstance(token, str)
-            or token not in event2idx
-            or not token.startswith(EVENT_PREFIXES)
-        ):
-            raise ValueError(
-                f"Unknown or unsupported event at position {position}: {token}"
-            )
-    positions = [i for i, token in enumerate(tokens) if token == "Bar_None"]
-    if len(positions) > 256:
-        raise ValueError("REMI files must have at most 256 bars.")
-    for bar_number, (left, right) in enumerate(
-        zip(positions, positions[1:] + [len(tokens)]), start=1
-    ):
-        if right - left > 128:
-            raise ValueError(f"Bar {bar_number} has more than 128 events.")
-        beat = -1
-        for i in range(left + 1, right):
-            token = tokens[i]
-            if token.startswith("Beat_"):
-                next_beat = int(token.removeprefix("Beat_"))
-                if next_beat < beat:
-                    raise ValueError(
-                        f"Beat positions must increase within bar {bar_number}."
-                    )
-                beat = next_beat
-            elif beat < 0:
-                raise ValueError(
-                    f"Bar {bar_number} must have a Beat event before musical events."
-                )
-            if token.startswith("Note_Pitch_") and (
-                i + 2 >= right
-                or not tokens[i + 1].startswith("Note_Velocity_")
-                or not tokens[i + 2].startswith("Note_Duration_")
-            ):
-                raise ValueError(
-                    f"Bar {bar_number} has a note without velocity and duration events."
-                )
-            if token.startswith("Note_Velocity_") and (
-                i == left or not tokens[i - 1].startswith("Note_Pitch_")
-            ):
-                raise ValueError(f"Bar {bar_number} has an orphan note velocity event.")
-            if token.startswith("Note_Duration_") and (
-                i < left + 2
-                or not tokens[i - 2].startswith("Note_Pitch_")
-                or not tokens[i - 1].startswith("Note_Velocity_")
-            ):
-                raise ValueError(f"Bar {bar_number} has an orphan note duration event.")
-    return positions, [_parse_event(token) for token in tokens]
-
-
 def _classes(events, n_bars):
     poly = np.zeros((n_bars * 16,), dtype=np.float32)
     rhythm = np.zeros_like(poly)
@@ -252,13 +139,9 @@ def generate(
     top_p,
     seed,
     output_dir,
-    midi_path=None,
-    remi_path=None,
 ):
-    if midi_path and remi_path:
-        raise ValueError("Upload either MIDI or REMI, not both.")
-    if not midi_path and not remi_path and sample_name not in EXAMPLES:
-        raise ValueError("Choose an example or upload a MIDI or REMI file.")
+    if sample_name not in EXAMPLES:
+        raise ValueError("Choose a preprocessed piano example.")
     n_bars, start_bar, seed = int(n_bars), int(start_bar), int(seed)
     if n_bars > 4:
         raise ValueError("Choose at most four bars per request.")
@@ -270,24 +153,10 @@ def generate(
     random.seed(seed)
     np.random.seed(seed)
     torch.manual_seed(seed)
-    conversion = None
-    if midi_path:
-        positions, all_events, conversion = midi_to_events(midi_path, event2idx)
-        events, bars, rhythm, poly = _piece(
-            positions, all_events, start_bar, n_bars, event2idx
-        )
-        source = Path(midi_path).name
-    elif remi_path:
-        positions, all_events = load_uploaded_events(remi_path, event2idx)
-        events, bars, rhythm, poly = _piece(
-            positions, all_events, start_bar, n_bars, event2idx
-        )
-        source = Path(remi_path).name
-    else:
-        events, bars, rhythm, poly = _sample(
-            EXAMPLES[sample_name], start_bar, n_bars, event2idx
-        )
-        source = sample_name
+    events, bars, rhythm, poly = _sample(
+        EXAMPLES[sample_name], start_bar, n_bars, event2idx
+    )
+    source = sample_name
     lengths = [len(bar) for bar in bars]
     encoder = torch.full((128, n_bars), len(event2idx), dtype=torch.long)
     mask = torch.ones((n_bars, 128), dtype=torch.bool)
@@ -374,6 +243,4 @@ def generate(
         "generated_events": len(tokens),
         "generated_notes": saved_notes,
     }
-    if conversion is not None:
-        details["midi_conversion"] = conversion
     return str(reference_path), str(output_path), details