Refactor audio processing and LSTM model for improved sound dynamics and melody generation

index.html

@@ -879,14 +879,14 @@
     const compressor = new Tone.Compressor({
         threshold: -14, ratio: 3, attack: 0.008, release: 0.18
     }).connect(limiter);
-    const eq = new Tone.EQ3({ low: -8, mid: 1, high: 4 }).connect(compressor);
+    const eq = new Tone.EQ3({ low: 5, mid: -1, high: 3 }).connect(compressor);
     const stereo = new Tone.StereoWidener(0.65).connect(eq);
     const reverb = new Tone.Reverb({ decay: 3.5, wet: 0.38 }).connect(stereo); // wet sẽ thay đổi theo BPM
     const delay  = new Tone.FeedbackDelay({ delayTime: "8n", feedback: 0.28, wet: 0.18 }).connect(reverb);
 
     // 🎹 PIANO — volume tăng lên, kết nối thẳng vào delay
     const piano = new Tone.Sampler({
-        volume: 2,   // +4dB so với trước (trước là 0)
+        volume: 4,   // +4dB so với trước (trước là 0)
         urls: {
             A1:"A1.mp3", C2:"C2.mp3", "D#2":"Ds2.mp3", "F#2":"Fs2.mp3",
             A2:"A2.mp3", C3:"C3.mp3", "D#3":"Ds3.mp3", "F#3":"Fs3.mp3",
@@ -895,14 +895,25 @@
         },
         baseUrl: "https://raw.githubusercontent.com/Tonejs/audio/master/salamander/",
         release: 1
-    }).connect(delay)
+    }).connect(delay);
+
+    // 🌊 PAD — volume tăng, attack thay đổi theo BPM
     const pad = new Tone.PolySynth(Tone.Synth, {
-            volume: -12,  
-            oscillator: { type: "triangle" },
-            envelope: { attack: 1.2, decay: 0.5, sustain: 0.8, release: 3 }
-        }).connect(reverb);
+        volume: -6,   // -6dB (trước là -12dB)
+        oscillator: { type: "sine" },
+        envelope: { attack: 1.2, decay: 0.5, sustain: 0.8, release: 3 }
+    }).connect(reverb);
+
+    // 🎸 BASS LINE — theo root của chord, luôn đúng tông
+    const bass = new Tone.Synth({
+        volume: -4,
+        oscillator: { type: "triangle" },
+        envelope: { attack: 0.04, decay: 0.3, sustain: 0.6, release: 1.2 }
+    }).connect(compressor);
+
     log("🎹 Đã khởi tạo audio chain. Volume boosted.");
     setStatus("Sẵn sàng sinh nhạc AI", "ok");
+
     // ================================================================
     // BPM-REACTIVE: thay đổi texture theo nhịp tim
     // ================================================================
@@ -914,16 +925,17 @@
 
         // Reverb: BPM CAO = nhiều reverb hơn (mơ màng, bay bổng, dịu)
         //         BPM thấp = ít reverb (rõ ràng, có chiều sâu nhẹ)
-        const reverbWet = bpm < 70  ? 0.2 :
-                          bpm < 90  ? 0.3 :
-                          bpm < 110 ? 0.4 : 0.5;
+        const reverbWet = bpm < 70  ? 0.28 :
+                          bpm < 90  ? 0.35 :
+                          bpm < 110 ? 0.46 : 0.58;
         reverb.wet.rampTo(reverbWet, 2.5);
 
         // Delay feedback: BPM cao = echo dài hơn (hypnotic, calming)
         const delayFb = bpm < 80 ? 0.16 : bpm < 110 ? 0.24 : 0.34;
         delay.feedback.rampTo(delayFb, 2.5);
-        // Nhạc tempo: BPM cao → tempo chậm hơn để kéo nhịp tim xuống
-        // map BPM [40,180] → music tempo [85, 55] BPM (inverse linear)
+
+        // Pad volume: BPM cao = pad nổi hơn (ambient nhấn chìm, che melody)
+        //             BPM thấp = pad lùi, melody groove rõ hơn
         const padVol = bpm < 75 ? -12 : bpm < 100 ? -8 : -4;
         pad.volume.rampTo(padVol, 2.5);
 
@@ -931,6 +943,8 @@
         const padAttack = bpm < 75 ? 0.6 : bpm < 100 ? 1.2 : 2.2;
         pad.set({ envelope: { attack: padAttack } });
 
+        // Nhạc tempo: BPM cao → tempo chậm hơn để kéo nhịp tim xuống
+        // map BPM [40,180] → music tempo [85, 55] BPM (inverse linear)
         const musicTempo = Math.round(85 - (bpm - 40) * (30 / 140));
         Tone.getTransport().bpm.rampTo(Math.max(52, Math.min(88, musicTempo)), 3);
 
@@ -968,7 +982,11 @@
         await Tone.start();
         await Tone.loaded();
         log("✅ Piano samples loaded");
-        masterGain.gain.rampTo(1.5, 0.1);
+
+        // Khôi phục gain (có thể đang = 0 nếu vừa Stop)
+        masterGain.gain.cancelScheduledValues(Tone.now());
+        masterGain.gain.setValueAtTime(1.5, Tone.now());
+
         if (ws) ws.close();
 
         setStatus(`Đang kết nối AI với ${currentBpm} BPM…`, 'info');
@@ -977,7 +995,7 @@
         btnStop.disabled        = false;
         bpmDisplay.style.animation = 'pulse 1s infinite';
 
-        // Khởi động texture + drum engine ngay
+        // Khởi động texture ngay
         applyBpmTexture(currentBpm);
 
         const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -993,9 +1011,9 @@
         ws.onmessage = (event) => {
             const data = JSON.parse(event.data);
 
-            // Nếu BPM thay đổi (server gửi về), cập nhật texture
-            if (data.bpm && data.bpm !== currentBpm) {
-                applyBpmTexture(data.bpm);
+            // Sync Transport BPM với music_bpm server trả về (entrainment tempo)
+            if (data.music_bpm) {
+                Tone.getTransport().bpm.rampTo(data.music_bpm, 2);
             }
 
             data.notes.forEach(n => {
@@ -1011,7 +1029,9 @@
                 else if (n.type === "chord") {
                     pad.triggerAttackRelease(noteStr, n.duration, t, n.velocity / 127);
                 }
-                // drum events từ server bị bỏ qua — drum engine client đã xử lý
+                else if (n.type === "bass") {
+                    bass.triggerAttackRelease(noteStr, n.duration, t, n.velocity / 127);
+                }
             });
 
             startTime += data.batch_duration;
@@ -1043,24 +1063,22 @@
     });
 
     // ================================================================
-    // STOP — fade masterGain ngay lập tức, không chờ note scheduled
+    // STOP — tắt ngay lập tức, không chờ note đã schedule trong buffer
     // ================================================================
     btnStop.addEventListener('click', () => {
         if (ws) { ws.close(); ws = null; }
 
-        // Fade out nhanh (0.25s) để tắt ngay cả note đã schedule trước
-        masterGain.gain.rampTo(0, 0.1);
+        // cancelScheduledValues triệt tiêu mọi ramp đang chờ,
+        // setValueAtTime(0) tắt gain TỨC THỜI — kể cả note đã queue sẵn.
+        // Gain KHÔNG được restore ở đây — chỉ restore khi nhấn Generate lại.
+        masterGain.gain.cancelScheduledValues(Tone.now());
+        masterGain.gain.setValueAtTime(0, Tone.now());
 
-        setTimeout(() => {
-            piano.releaseAll();
-            pad.releaseAll();
-        }, 200);
+        piano.releaseAll();
+        pad.releaseAll();
+        bass.triggerRelease();
 
         setStatus('Đã dừng nhạc.', 'info');
-
-        btnGenerate.disabled = false;
-        btnStop.disabled = true;
-        bpmDisplay.style.animation = 'none';
     });
 </script>
 </body>

main.py

@@ -24,13 +24,7 @@ class BioVibeAI(nn.Module):
     def __init__(self, vocab_size):
         super().__init__()
         self.embedding = nn.Embedding(vocab_size, 256)
-        self.lstm = nn.LSTM(
-            256,
-            512,
-            num_layers=3,
-            batch_first=True,
-            dropout=0.3
-        )
+        self.lstm = nn.LSTM(256, 512, num_layers=3, batch_first=True, dropout=0.3)
         self.norm = nn.LayerNorm(512)
         self.fc = nn.Linear(512, vocab_size)
 
@@ -41,30 +35,22 @@ class BioVibeAI(nn.Module):
         out = self.norm(out)
         return self.fc(out), hidden
 
-# ==========================================
-# LOAD MODEL
-# ==========================================
-with open("mapping_dict.pkl", "rb") as f:
+with open('mapping_dict.pkl', 'rb') as f:
     int_to_note = pickle.load(f)
-
 note_to_int = {n: i for i, n in int_to_note.items()}
 vocab_size = len(int_to_note)
 
 device = torch.device("cpu")
-
 model = BioVibeAI(vocab_size=vocab_size)
-
 state_dict = torch.load("model.pth", map_location=device)
-
 clean_state_dict = {
-    k[7:] if k.startswith("module.") else k: v
+    k[7:] if k.startswith('module.') else k: v
     for k, v in state_dict.items()
 }
-
 model.load_state_dict(clean_state_dict)
 model.eval()
 
-with open("notes_corpus.pkl", "rb") as f:
+with open('notes_corpus.pkl', 'rb') as f:
     corpus = pickle.load(f)
 
 # ==========================================
@@ -73,68 +59,65 @@ with open("notes_corpus.pkl", "rb") as f:
 SEQ_LEN = 128
 BARS_PER_BATCH = 2
 
-# Scale cực kỳ an toàn, nghe chill/anime/lofi
-SAFE_SCALE = {
-    60, 62, 64, 65, 67, 69, 71,
-    72, 74, 76, 77, 79
-}
-
+# Chord progressions — 2 màu sắc luân phiên để tránh lặp
 CHORD_SETS = {
-    "calm": [
-        [60, 64, 67, 71],   # Cmaj7
-        [62, 65, 69, 72],   # Dm7
-        [64, 67, 71, 74],   # Em7
-        [65, 69, 72, 76],   # Fmaj7
+    "calm": [            # BPM cao — tông mềm, dreamy
+        [48, 52, 55, 59],    # Cmaj7
+        [45, 48, 52, 55],    # Am7
+        [41, 45, 48, 52],    # Fmaj7
+        [43, 47, 50, 55],    # G9
     ],
-
-    "groove": [
-        [60, 64, 67],       # C
-        [67, 71, 74],       # G
-        [69, 72, 76],       # Am
-        [65, 69, 72],       # F
+    "groove": [          # BPM thấp — tông rõ hơn, có chiều sâu
+        [48, 52, 55, 59],    # Cmaj7
+        [43, 47, 50, 53],    # G7
+        [45, 48, 52, 57],    # Am9
+        [41, 44, 48, 52],    # Fm7
     ],
 }
 
 # ==========================================
-# MUSIC HELPERS
+# ENTRAINMENT HELPERS
 # ==========================================
+
 def get_music_beat(bpm: int) -> float:
     """
-    BPM cao -> nhạc hơi nhanh hơn chút
-    nhưng vẫn giữ relaxing.
+    Tim đập nhanh -> nhac cham lai de keo nhip tim xuong (entrainment).
+    BPM [40->180] => music_tempo [85->55] BPM (nghich chieu).
     """
-    music_tempo = 60.0 + (bpm - 40) * (18.0 / 140.0)
-    music_tempo = max(58.0, min(82.0, music_tempo))
+    music_tempo = 85.0 - (bpm - 40) * (30.0 / 140.0)
+    music_tempo = max(52.0, min(88.0, music_tempo))
     return 60.0 / music_tempo
 
 
 def get_temperature(bpm: int) -> float:
     """
-    Temperature thấp hơn để:
-    - ít random
-    - ít uncanny
-    - ổn định hơn
+    BPM cao -> temp THAP -> melody on dinh, du doan duoc, calming.
+    BPM thap -> temp CAO -> melody da dang, groovy hon.
+    Range: [0.60, 0.92]
     """
     t = (bpm - 40) / (180 - 40)
-    return round(0.72 - t * 0.18, 3)
+    return round(0.92 - t * 0.32, 3)
 
 
 def get_melody_params(bpm: int, music_beat: float) -> dict:
+    """
+    BPM cao -> not nhe hon, dai hon (legato), range cao (airy).
+    BPM thap -> not vua, ngan hon (rhythmic), range mid.
+    """
     t = (bpm - 40) / (180 - 40)
 
-    vel_low  = int(58 - t * 12)
-    vel_high = int(72 - t * 10)
+    vel_low  = int(75 - t * 28)    # 75 (bpm=40) -> 47 (bpm=180)
+    vel_high = int(90 - t * 22)    # 90 -> 68
 
-    dur_factor = 0.55 + t * 0.22
+    dur_factor = 0.72 + t * 0.48   # 0.72 -> 1.20 (legato khi BPM cao)
+    duration   = round(music_beat * dur_factor, 4)
 
-    duration = round(music_beat * dur_factor, 4)
-
-    midi_low  = 60
-    midi_high = 79
+    midi_low  = int(59 + t * 5)    # 59 -> 64
+    midi_high = int(71 + t * 5)    # 71 -> 76
 
     return {
-        "vel_low": max(42, vel_low),
-        "vel_high": max(56, vel_high),
+        "vel_low": max(40, vel_low),
+        "vel_high": max(60, vel_high),
         "duration": duration,
         "midi_low": midi_low,
         "midi_high": midi_high,
@@ -142,316 +125,155 @@ def get_melody_params(bpm: int, music_beat: float) -> dict:
 
 
 def get_chord_set(bpm: int, bar_count: int) -> list:
-    use_groove = bpm < 82
+    """
+    BPM cao -> chord calm (Cmaj7/Am7/Fmaj7/G9).
+    BPM thap -> chord groove (co Fm7 them mau).
+    Doi chord set moi 16 bar.
+    """
+    use_groove = (bpm < 85) or (bar_count % 16 >= 8 and bpm < 110)
     return CHORD_SETS["groove"] if use_groove else CHORD_SETS["calm"]
 
 
 # ==========================================
-# WEBSOCKET
+# WEBSOCKET ENDPOINT
 # ==========================================
 @app.websocket("/ws/vibe")
 async def websocket_vibe(websocket: WebSocket):
-
     await websocket.accept()
 
     current_bpm = 75
-    is_playing = True
+    is_playing  = True
 
     async def listen():
         nonlocal current_bpm, is_playing
-
         try:
             while True:
                 data = await websocket.receive_json()
-
                 bpm = int(data.get("bpm", current_bpm))
-
                 if 40 <= bpm <= 180:
                     current_bpm = bpm
-
         except Exception:
             is_playing = False
 
     asyncio.create_task(listen())
 
-    # ==========================================
-    # SEED
-    # ==========================================
-    lofi_songs = [
-        s for s in corpus
-        if s and len(s) >= SEQ_LEN and s[0] == "STYLE_LOFI"
-    ]
-
-    pool = lofi_songs if lofi_songs else [
-        s for s in corpus if len(s) >= SEQ_LEN
-    ]
-
+    # Chon seed uu tien LOFI
+    lofi_songs = [s for s in corpus if s and len(s) >= SEQ_LEN and s[0] == "STYLE_LOFI"]
+    pool = lofi_songs if lofi_songs else [s for s in corpus if len(s) >= SEQ_LEN]
     song = random.choice(pool)
 
     seed = list(song[:SEQ_LEN])
     seed[0] = "STYLE_LOFI"
-
     pattern = [note_to_int.get(tok, 0) for tok in seed]
 
+    # Warm-up LSTM mot lan duy nhat voi toan bo seed
     with torch.no_grad():
         seed_tensor = torch.tensor([pattern], dtype=torch.long)
         _, hidden = model(seed_tensor)
 
     bar_count = 0
 
-    # ==========================================
-    # MAIN LOOP
-    # ==========================================
     try:
-
         while is_playing:
-
             bpm = current_bpm
 
             music_beat = get_music_beat(bpm)
+            bar_dur    = music_beat * 4
+            batch_dur  = bar_dur * BARS_PER_BATCH
+            temp       = get_temperature(bpm)
+            mel_params = get_melody_params(bpm, music_beat)
+            chords     = get_chord_set(bpm, bar_count)
 
-            bar_dur = music_beat * 4
-
-            batch_dur = bar_dur * BARS_PER_BATCH
-
-            temp = get_temperature(bpm)
-
-            mel_params = get_melody_params(
-                bpm,
-                music_beat
-            )
-
-            chords = get_chord_set(
-                bpm,
-                bar_count
-            )
-
-            # ==========================================
-            # GENERATE MELODY
-            # ==========================================
+            # ── SINH MELODY ──────────────────────────────────────────────
             melody_notes = []
-
             current_time = 0.0
-
-            last_midi = None
-
-            MAX_TOKENS = 180
-
-            note_density = 0
+            last_midi    = None
+            MAX_TOKENS   = 180
 
             for _ in range(MAX_TOKENS):
-
                 if current_time >= batch_dur:
                     break
 
-                # tránh quá dày note
-                if note_density > 24 and random.random() < 0.50:
-                    current_time += music_beat * 0.5
-                    continue
-
-                new_tok = torch.tensor(
-                    [[pattern[-1]]],
-                    dtype=torch.long
-                )
-
+                new_tok = torch.tensor([[pattern[-1]]], dtype=torch.long)
                 with torch.no_grad():
                     logits, hidden = model(new_tok, hidden)
+                    probs = torch.softmax(logits / temp, dim=1).numpy()[0]
+                    idx   = int(np.random.choice(len(probs), p=probs))
 
-                    probs = torch.softmax(
-                        logits / temp,
-                        dim=1
-                    ).numpy()[0]
-
-                    idx = int(
-                        np.random.choice(
-                            len(probs),
-                            p=probs
-                        )
-                    )
-
-                tok = int_to_note[idx]
-
+                tok     = int_to_note[idx]
                 pattern = pattern[1:] + [idx]
 
-                # ==========================================
-                # TIME TOKEN
-                # ==========================================
                 if tok.startswith("TIME_"):
-
                     try:
-                        gap_beats = float(tok.split("_")[1])
-
-                        # hạn chế gap quá dài
-                        gap_beats = min(gap_beats, 1.5)
-
+                        gap_beats    = float(tok.split("_")[1])
                         current_time += gap_beats * music_beat
-
                     except ValueError:
                         pass
 
-                # ==========================================
-                # NOTE TOKEN
-                # ==========================================
                 elif tok.startswith("NOTE_"):
-
                     try:
                         midi = int(tok.split("_")[1])
+                        lo, hi = mel_params["midi_low"], mel_params["midi_high"]
 
-                        lo = mel_params["midi_low"]
-                        hi = mel_params["midi_high"]
-
-                        while midi < lo:
-                            midi += 12
-
-                        while midi > hi:
-                            midi -= 12
-
-                        # snap scale
-                        midi = min(
-                            SAFE_SCALE,
-                            key=lambda x: abs(x - midi)
-                        )
+                        while midi < lo: midi += 12
+                        while midi > hi: midi -= 12
 
-                        # tránh lặp note
                         if midi == last_midi and random.random() < 0.40:
-
-                            step = random.choice([
-                                -2, -1, 1, 2, 3
-                            ])
-
-                            midi += step
-
-                            midi = min(
-                                SAFE_SCALE,
-                                key=lambda x: abs(x - midi)
-                            )
-
-                        # tránh jump lớn
-                        if last_midi is not None:
-
-                            if abs(midi - last_midi) > 5:
-
-                                midi = last_midi + random.choice([
-                                    -2, -1, 1, 2
-                                ])
-
-                                midi = min(
-                                    SAFE_SCALE,
-                                    key=lambda x: abs(x - midi)
-                                )
+                            step = random.choice([-2, 2, 3, -3, 5])
+                            midi = max(lo - 2, min(hi + 2, midi + step))
 
                         last_midi = midi
-
-                        velocity = random.randint(
-                            mel_params["vel_low"],
-                            mel_params["vel_high"]
-                        )
-
+                        velocity  = random.randint(mel_params["vel_low"],
+                                                   mel_params["vel_high"])
                         melody_notes.append({
-                            "note": midi,
+                            "note":     midi,
                             "velocity": velocity,
                             "duration": mel_params["duration"],
-                            "type": "melody",
-                            "time": round(current_time, 4),
+                            "type":     "melody",
+                            "time":     round(current_time, 4),
                         })
-
-                        note_density += 1
-
-                        # breathing space
-                        if random.random() < 0.18:
-                            current_time += (
-                                music_beat *
-                                random.choice([0.25, 0.5])
-                            )
-
                     except ValueError:
                         pass
 
-            # ==========================================
-            # FALLBACK
-            # ==========================================
+            # Fallback pentatonic
             if len(melody_notes) < 3:
-
                 scale = [60, 62, 64, 67, 69, 72]
-
                 t = 0.0
-
                 while t < batch_dur:
-
                     melody_notes.append({
-                        "note": random.choice(scale),
-                        "velocity": random.randint(
-                            mel_params["vel_low"],
-                            mel_params["vel_high"]
-                        ),
+                        "note":     random.choice(scale),
+                        "velocity": random.randint(mel_params["vel_low"],
+                                                   mel_params["vel_high"]),
                         "duration": mel_params["duration"],
-                        "type": "melody",
-                        "time": round(t, 4),
+                        "type":     "melody",
+                        "time":     round(t, 4),
                     })
+                    t += music_beat * random.choice([0.5, 0.5, 1.0])
 
-                    t += music_beat * random.choice([
-                        0.5,
-                        1.0
-                    ])
-
-            # ==========================================
-            # FILTER OVERDENSITY
-            # ==========================================
-            melody_notes.sort(key=lambda x: x["time"])
-
-            filtered = []
-
-            last_t = -999
-
-            for n in melody_notes:
-
-                if n["time"] - last_t > 0.12:
-                    filtered.append(n)
-                    last_t = n["time"]
-
-            melody_notes = filtered
-
-            # ==========================================
-            # CHORD PADS
-            # ==========================================
-            chord_vel = max(
-                26,
-                int(42 - (bpm - 40) * 0.04)
-            )
+            # ── CHORD PADS ───────────────────────────────────────────────
+            # BPM cao -> pad nhe, am thanh (ambient)
+            chord_vel = max(32, int(50 - (bpm - 40) * 0.06))
 
             chord_notes = []
-
             for bar_i in range(BARS_PER_BATCH):
-
-                # chord giữ lâu hơn
-                chord = chords[
-                    ((bar_count + bar_i) // 2)
-                    % len(chords)
-                ]
-
+                chord = chords[(bar_count + bar_i) % len(chords)]
                 t = bar_i * bar_dur
-
                 for c in chord:
-
                     chord_notes.append({
-                        "note": c,
+                        "note":     c,
                         "velocity": chord_vel,
-                        "duration": round(bar_dur * 1.8, 4),
-                        "type": "chord",
-                        "time": round(t, 4),
+                        "duration": round(bar_dur * 0.95, 4),
+                        "type":     "chord",
+                        "time":     round(t, 4),
                     })
 
-            # ==========================================
-            # SEND
-            # ==========================================
             await websocket.send_json({
-                "notes": melody_notes + chord_notes,
+                "notes":          melody_notes + chord_notes,
                 "batch_duration": round(batch_dur, 4),
-                "music_bpm": round(60.0 / music_beat, 1),
+                "music_bpm":      round(60.0 / music_beat, 1),
             })
 
             bar_count += BARS_PER_BATCH
-
             await asyncio.sleep(batch_dur * 0.80)
 
     except Exception: