Add sampled guitar and bass with effects; make YuE2 opt-in

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.12-slim
+FROM python:3.12-slim-bookworm
 
 ENV DEBIAN_FRONTEND=noninteractive \
     PYTHONUNBUFFERED=1 \
@@ -6,9 +6,24 @@ ENV DEBIAN_FRONTEND=noninteractive \
     GRADIO_ANALYTICS_ENABLED=False
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    ffmpeg fluidsynth libsndfile1 libgomp1 && \
+    ffmpeg fluidsynth libsndfile1 libgomp1 curl ca-certificates p7zip-full && \
     rm -rf /var/lib/apt/lists/*
 
+# Full multi-sampled CC0 electric guitar and bass. Pin release archives so a
+# changed upstream download cannot silently change audible results.
+RUN mkdir -p /opt/soundfonts /tmp/fonts && \
+    curl -fL --retry 3 -o /tmp/guitar.7z \
+      'https://github.com/freepats/electric-guitar-FSBS-clean/releases/download/2026-08-07/EGuitarFSBS-clean-SF2-20260807.7z' && \
+    echo '6d338afefe0efb629afd9ba28a5c8c129fc28b97ef1b57a31ebceb7bf0e3bf65  /tmp/guitar.7z' | sha256sum -c - && \
+    7z x -y -o/tmp/fonts /tmp/guitar.7z >/dev/null && \
+    mv '/tmp/fonts/EGuitarFSBS-clean SF2-20260807/EGuitarFSBS-clean bridge 20260807.sf2' /opt/soundfonts/electric-clean.sf2 && \
+    curl -fL --retry 3 -o /tmp/bass.7z \
+      'https://github.com/freepats/electric-bass-YR/releases/download/2019-09-30/FingerBassYR-SF2-20190930.7z' && \
+    echo 'f5b5cfe04435a9e9037d1f97d515dc596535acf26637db9579d724cd757f179e  /tmp/bass.7z' | sha256sum -c - && \
+    7z x -y -o/tmp/fonts /tmp/bass.7z >/dev/null && \
+    mv '/tmp/fonts/FingerBassYR SF2-20190930/FingerBassYR 20190930.sf2' /opt/soundfonts/finger-bass.sf2 && \
+    rm -rf /tmp/fonts /tmp/guitar.7z /tmp/bass.7z
+
 # SheetSage2's published code uses the older Transformers API. Separate
 # processes keep that runtime independent of YuE2's pinned dependencies.
 RUN python -m venv /opt/sheet && /opt/sheet/bin/pip install --no-cache-dir \

README.md

@@ -16,15 +16,21 @@ models:
 
 # Hum
 
-Upload a short hum or record one in the browser. One request generates six
-comparisons. SheetSage2 extracts source-timed notes and beats; FluidSynth
-renders an instrument alone and the same instrument with a GM drum kit placed
-on those beats. A continuous-F0 synth follows voice pitch and amplitude. A
-single YuE2 model load produces solo, melody-with-drums, and composition
-variants from the SheetSage2 ABC. YuE2 drums are requested in the style prompt,
-not imposed as a separate symbolic track. YuE2 can introduce voices or other
-sounds and does not preserve source timing exactly. The three deterministic
-previews appear first; YuE2 previews then appear as each generation finishes.
+Upload a short hum or record one in the browser. One request generates seven
+source-timed comparisons. SheetSage2 extracts notes and beats; FluidSynth
+renders an instrument alone and with a GM drum kit, plus sampled electric
+guitar and fingered bass in clean and processed versions. The bass is shifted
+down one octave, with note starts and lengths preserved. A continuous-F0 synth
+follows voice pitch and amplitude. The sampler uses full-size FreePats electric
+guitar and fingered bass SoundFonts, with FFmpeg compression, filtering,
+oversampled soft clipping, and a short guitar room echo in processed versions.
+
+YuE2 is off by default. Checking its option adds three slow experiments from
+SheetSage2 ABC: solo, melody-with-drums, and composition. The drums in these
+experiments are requested in the style prompt, not imposed as a separate
+symbolic track. YuE2 can introduce voices or other sounds and does not
+preserve source timing exactly. Sampler previews appear first; optional YuE2
+previews then appear as each generation finishes.
 
 Output audio is downloadable 320 kbit/s CBR MP3. This Space is public: uploads
 are processed on its Hugging Face server and results are served from temporary
@@ -40,5 +46,13 @@ Model licenses and source: [SheetSage2](https://huggingface.co/m-a-p/SheetSage2)
 [YuE2-3B](https://huggingface.co/m-a-p/YuE2-3B),
 [YuE2-Vae](https://huggingface.co/m-a-p/YuE2-Vae).
 
+Sample library sources, both CC0 1.0: [FreePats FSBS Clean Electric Guitar](https://freepats.zenvoid.org/ElectricGuitar/clean-electric-guitar.html)
+(full SF2, release 2026-08-07; archive SHA-256
+`6d338afefe0efb629afd9ba28a5c8c129fc28b97ef1b57a31ebceb7bf0e3bf65`),
+and [FreePats Finger Bass YR](https://freepats.zenvoid.org/ElectricGuitar/clean-electric-bass.html)
+(SF2, release 2019-09-30; archive SHA-256
+`f5b5cfe04435a9e9037d1f97d515dc596535acf26637db9579d724cd757f179e`).
+The Docker build verifies both archives before extraction.
+
 This is a research prototype; a single owner-reviewed recording is development
 evidence, not a general accuracy guarantee.

app.py

@@ -29,12 +29,12 @@ def suggest_prompts(instrument: str) -> tuple[str, str, str]:
 
 
 def run(audio: str | None, instrument: str, solo_style: str, drum_style: str,
-        arrangement_style: str, seed: int,
+        arrangement_style: str, seed: int, include_yue: bool,
         progress: gr.Progress = gr.Progress(track_tqdm=False)):
     try:
         styles = {"yue_solo": solo_style, "yue_drums": drum_style,
                   "yue_arrangement": arrangement_style}
-        yield from generate_all(audio, instrument, styles, int(seed), progress)
+        yield from generate_all(audio, instrument, styles, int(seed), include_yue, progress)
     except Exception as error:
         raise gr.Error(str(error)) from error
 
@@ -52,13 +52,15 @@ CSS = """
 with gr.Blocks(title="Hum · напев в инструмент", css=CSS, theme=gr.themes.Soft()) as demo:
     gr.HTML("""<div id='hero'><h1>Hum <span style='color:#6474db'>♪</span></h1>
     <p>Напойте фразу в микрофон или загрузите короткую запись. Один запуск
-    создаст все варианты: инструмент, инструмент с барабанами, непрерывный
-    синтез и три эксперимента YuE2.</p></div>""")
+    создаст все сэмплерные варианты с исходными нотами и временем: инструмент,
+    электрогитару, бас и эффекты. YuE2 включается по желанию.</p></div>""")
     with gr.Row():
         with gr.Column(scale=4):
             audio = gr.Audio(label="Ваш напев", sources=["microphone", "upload"],
                              type="filepath", format="wav")
             instrument = gr.Dropdown(list(INSTRUMENTS), value="Флейта", label="Инструмент")
+            include_yue = gr.Checkbox(label="Дополнительно запустить YuE2 · три генерации (~3 минуты)",
+                                      value=False)
             with gr.Accordion("Настройки YuE2", open=False):
                 defaults = suggest_prompts("Флейта")
                 solo_style = gr.Textbox(label="Соло · style", lines=2, value=defaults[0])
@@ -67,10 +69,12 @@ with gr.Blocks(title="Hum · напев в инструмент", css=CSS, theme
                 arrangement_style = gr.Textbox(label="Композиция · style", lines=2,
                                                value=defaults[2])
                 seed = gr.Number(label="Seed", value=4096, precision=0)
-            go = gr.Button("Создать все варианты", variant="primary", size="lg")
+            go = gr.Button("Создать сэмплерные варианты", variant="primary", size="lg")
             gr.HTML("""<div class='note'><b>Текущая цель:</b> один инструмент и
-            приблизительно исходное время — первые два варианта. Барабаны
-            привязаны к долям, которые нашёл SheetSage2. YuE2 может изменить
+            приблизительно исходное время. Электрогитара и бас используют
+            записанные сэмплы; бас звучит октавой ниже. Обработанные версии
+            добавляют усиление и лёгкий эффект, но не новые ноты. Барабаны
+            привязаны к долям SheetSage2. YuE2 может изменить
             длительность, добавить человеческие звуки или другие инструменты;
             отсутствие вокала не гарантируется. Это публичный Space: записи
             обрабатываются на сервере Hugging Face.</div>""")
@@ -83,6 +87,14 @@ with gr.Blocks(title="Hum · напев в инструмент", css=CSS, theme
                                                 interactive=False)
                     contour = gr.Audio(label="Непрерывная высота · synth",
                                        interactive=False)
+                    guitar_clean = gr.Audio(label="Электрогитара · чистая",
+                                            interactive=False)
+                    guitar_amp = gr.Audio(label="Электрогитара · усилитель и эффекты",
+                                          interactive=False)
+                    bass_clean = gr.Audio(label="Бас · чистый",
+                                          interactive=False)
+                    bass_amp = gr.Audio(label="Бас · тёплый усилитель",
+                                        interactive=False)
                 with gr.Column():
                     yue_solo = gr.Audio(label="YuE2 · соло", interactive=False)
                     yue_drums = gr.Audio(label="YuE2 · мелодия + барабаны",
@@ -98,8 +110,9 @@ with gr.Blocks(title="Hum · напев в инструмент", css=CSS, theme
     instrument.change(suggest_prompts, inputs=instrument,
                       outputs=[solo_style, drum_style, arrangement_style])
     go.click(run, inputs=[audio, instrument, solo_style, drum_style,
-                          arrangement_style, seed],
+                          arrangement_style, seed, include_yue],
              outputs=[instrument_only, instrument_drums, contour,
+                      guitar_clean, guitar_amp, bass_clean, bass_amp,
                       yue_solo, yue_drums, yue_arrangement,
                       midi, drum_midi, beat_lab, abc, details], show_progress="full")
 

pipeline.py

@@ -17,8 +17,10 @@ from logic import INSTRUMENTS, drum_hits, instrumental_abc, validate_duration
 ROOT = Path(__file__).resolve().parent
 SHEET_PYTHON = Path(os.environ.get("HUM_SHEET_PYTHON", "/opt/sheet/bin/python"))
 YUE_PYTHON = Path(os.environ.get("HUM_YUE_PYTHON", "/opt/yue/bin/python"))
+SOUNDFONT_DIR = Path(os.environ.get("HUM_SOUNDFONTS", "/opt/soundfonts"))
 VARIANTS = (
     "instrument", "instrument_drums", "contour",
+    "guitar_clean", "guitar_amp", "bass_clean", "bass_amp",
     "yue_solo", "yue_drums", "yue_arrangement",
 )
 
@@ -72,12 +74,13 @@ def transcribe(pcm24: Path, folder: Path, log: Path) -> tuple[Path, Path, Path,
             folder / "full.abc", folder / "beat.lab")
 
 
-def render_midi(midi_path: Path, output: Path, duration: float, log: Path) -> Path:
+def render_midi(midi_path: Path, output: Path, duration: float, log: Path,
+                soundfont: Path | None = None) -> Path:
     import numpy as np
     import pretty_midi
     import soundfile as sf
 
-    soundfont = Path(pretty_midi.__file__).parent / "TimGM6mb.sf2"
+    soundfont = soundfont or Path(pretty_midi.__file__).parent / "TimGM6mb.sf2"
     if not soundfont.is_file():
         raise RuntimeError("SoundFont missing from pretty_midi installation")
     raw = output.with_name(output.stem + "-tail.wav")
@@ -94,25 +97,61 @@ def render_midi(midi_path: Path, output: Path, duration: float, log: Path) -> Pa
     return output
 
 
-def render_instrument(midi_path: Path, folder: Path, instrument: str,
-                      duration: float, log: Path) -> tuple[Path, Path]:
+def render_preset(midi_path: Path, folder: Path, name: str, program: int,
+                  duration: float, log: Path, *, soundfont: Path | None = None,
+                  transpose: int = 0) -> tuple[Path, Path]:
     import pretty_midi
 
-    if instrument not in INSTRUMENTS:
-        raise ValueError("Неизвестный инструмент")
     source = pretty_midi.PrettyMIDI(str(midi_path))
     notes = [n for track in source.instruments for n in track.notes]
     if not notes:
         raise RuntimeError("SheetSage2 не нашёл нот в напеве")
     midi = pretty_midi.PrettyMIDI(initial_tempo=120, resolution=10000)
-    track = pretty_midi.Instrument(program=INSTRUMENTS[instrument][0], name="Melody")
+    track = pretty_midi.Instrument(program=program, name=name)
     for note in notes:
-        track.notes.append(pretty_midi.Note(velocity=90, pitch=note.pitch,
+        pitch = note.pitch + transpose
+        if not 0 <= pitch <= 127:
+            raise ValueError("Транспонированная нота вне MIDI-диапазона")
+        track.notes.append(pretty_midi.Note(velocity=90, pitch=pitch,
                                             start=note.start, end=note.end))
     midi.instruments.append(track)
-    rendered_midi = folder / "instrument.mid"
+    rendered_midi = folder / f"{name}.mid"
     midi.write(str(rendered_midi))
-    return render_midi(rendered_midi, folder / "instrument.wav", duration, log), rendered_midi
+    return (render_midi(rendered_midi, folder / f"{name}.wav", duration, log,
+                        soundfont=soundfont), rendered_midi)
+
+
+def render_instrument(midi_path: Path, folder: Path, instrument: str,
+                      duration: float, log: Path) -> tuple[Path, Path]:
+    if instrument not in INSTRUMENTS:
+        raise ValueError("Неизвестный инструмент")
+    return render_preset(midi_path, folder, "instrument", INSTRUMENTS[instrument][0],
+                         duration, log)
+
+
+def apply_effect(source: Path, output: Path, kind: str, duration: float,
+                 log: Path) -> Path:
+    # Both chains use the same sampled notes and retain the source duration.
+    chains = {
+        "guitar": ("highpass=f=75,acompressor=threshold=0.08:ratio=2.5:"
+                   "attack=8:release=90,volume=2.2,"
+                   "asoftclip=type=tanh:threshold=0.55:oversample=4,"
+                   "lowpass=f=6500,aecho=0.9:0.85:75:0.08"),
+        "bass": ("highpass=f=32,lowpass=f=4500,"
+                 "acompressor=threshold=0.09:ratio=3:attack=12:release=120,"
+                 "volume=1.65,asoftclip=type=tanh:threshold=0.72:oversample=4"),
+    }
+    if kind not in chains:
+        raise ValueError("Неизвестный эффект")
+    command(["ffmpeg", "-nostdin", "-v", "error", "-y", "-i", str(source),
+             "-af", chains[kind], "-t", f"{duration:.6f}", "-ar", "48000",
+             "-c:a", "pcm_f32le", str(output)], log, timeout=120)
+    import numpy as np
+    import soundfile as sf
+    audio, rate = sf.read(output, dtype="float32", always_2d=True)
+    if rate != 48000 or abs(len(audio) - round(duration * rate)) > 1 or not np.isfinite(audio).all():
+        raise RuntimeError("Эффект нарушил длительность или повредил аудио")
+    return output
 
 
 def render_drums(melody_midi: Path, beat_lab: Path, folder: Path,
@@ -256,7 +295,7 @@ def render_yue_batch(melody_abc: Path, full_abc: Path, folder: Path,
 
 
 def encode_mp3(source: Path, destination: Path, log: Path,
-               normalize: bool = True) -> None:
+               normalize: bool = True, max_gain: float = 4.) -> None:
     import numpy as np
     import soundfile as sf
 
@@ -266,7 +305,7 @@ def encode_mp3(source: Path, destination: Path, log: Path,
     peak = float(np.max(np.abs(audio)))
     if peak <= 1e-8:
         raise RuntimeError("Результат слишком тихий")
-    gain = min(4., .95 / peak) if normalize else 1.
+    gain = min(max_gain, .8 / peak) if normalize else 1.
     safe = destination.with_suffix(".safe.wav")
     sf.write(safe, audio * gain, rate, subtype="PCM_24")
     command(["ffmpeg", "-nostdin", "-v", "error", "-y", "-i", str(safe),
@@ -277,6 +316,7 @@ def encode_mp3(source: Path, destination: Path, log: Path,
 
 
 def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int,
+                 include_yue: bool = False,
                  progress=None) -> Iterator[tuple]:
     if not source or instrument not in INSTRUMENTS:
         raise ValueError("Загрузите или запишите напев и выберите инструмент")
@@ -292,9 +332,10 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
     drum_count = 0
     drums_midi = None
 
-    def deliver(name: str, raw: Path, *, normalize: bool = True) -> None:
+    def deliver(name: str, raw: Path, *, normalize: bool = True,
+                max_gain: float = 4.) -> None:
         destination = folder / f"{name}.mp3"
-        encode_mp3(raw, destination, log, normalize=normalize)
+        encode_mp3(raw, destination, log, normalize=normalize, max_gain=max_gain)
         outputs[name] = str(destination)
         durations[name] = round(__import__("soundfile").info(raw).duration, 3)
 
@@ -302,9 +343,10 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
         metadata = {"instrument": instrument, "source_sha256": digest,
                     "source_seconds": round(duration, 3),
                     "result_seconds": dict(durations), "drum_hits": drum_count,
-                    "yue_timing": dict(yue_timing),
+                    "yue_requested": include_yue, "yue_timing": dict(yue_timing),
                     "errors": dict(errors), "complete": complete,
-                    "source_timing_preserved": ["instrument", "instrument_drums", "contour"],
+                    "source_timing_preserved": list(VARIANTS[:7]),
+                    "bass_transpose_semitones": -12,
                     "yue_vocal_absence_guaranteed": False,
                     "elapsed_seconds": round(time.monotonic() - began, 2)}
         return (*(outputs[name] for name in VARIANTS), str(melody_midi),
@@ -339,6 +381,28 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
     (folder / "instrumental-melody.abc").write_text(
         instrumental_abc(melody_abc.read_text()))
     yield snapshot()
+    if progress:
+        progress(.48, desc="Сэмплирую электрогитару и бас")
+    for name, font_name, transpose, effect in (
+        ("guitar_clean", "electric-clean.sf2", 0, "guitar"),
+        ("bass_clean", "finger-bass.sf2", -12, "bass"),
+    ):
+        try:
+            raw, _ = render_preset(midi, folder, name, 0, duration, log,
+                                   soundfont=SOUNDFONT_DIR / font_name,
+                                   transpose=transpose)
+            deliver(name, raw, max_gain=20.)
+            deliver(name.replace("clean", "amp"),
+                    apply_effect(raw, folder / f"{name}-amp.wav", effect,
+                                 duration, log), max_gain=20.)
+        except (ValueError, RuntimeError, OSError) as error:
+            errors[name] = str(error)
+    yield snapshot()
+    if not include_yue:
+        final = snapshot(complete=True)
+        (folder / "result.json").write_text(json.dumps(final[-1], ensure_ascii=False, indent=2) + "\n")
+        yield final
+        return
     if progress:
         progress(.50, desc="YuE2 создаёт сразу три варианта; это займёт несколько минут")
     completed = set()