Update app.py

app.py

@@ -77,21 +77,17 @@ class AudioMathRockModel(nn.Module):
         self.tmp_head  = nn.Linear(512, len(TEMPO_LABELS))
 
     def forward(self, wavlm_values, clap_values):
-        # Extract features from frozen/unfrozen backbones
         wavlm_feats = self.wavlm(wavlm_values).last_hidden_state.mean(dim=1)
         clap_feats  = self.clap(clap_values).pooler_output
         
-        # Audio Mel representation mapping context
         with torch.no_grad():
             mel = self.mel_spectrogram(wavlm_values.float())
             mel_db = self.amplitude_to_db(mel)
         
-        # Align precision and pass through CNN branch
         cnn_feats = F.gelu(self.cnn_extractor(mel_db.unsqueeze(1))).to(wavlm_feats.dtype)
         wlm_p = F.gelu(self.wlm_proj(wavlm_feats))
         clp_p = F.gelu(self.clp_proj(clap_feats))
         
-        # Late fusion sequence
         fused = self.fusion(torch.cat([wlm_p, clp_p, cnn_feats], dim=-1))
         return self.emo_head(fused), self.vibe_head(fused), self.int_head(fused), self.tmp_head(fused)
 
@@ -139,14 +135,12 @@ def analyze_track(audio_path, lyrics_input):
         wav_orig, orig_sr = librosa.load(audio_path, sr=None, mono=True)
         waveform = torch.tensor(wav_orig).unsqueeze(0)
         
-        # Resampling constraints based on model requirements
         wlm_wave = torchaudio.functional.resample(waveform, orig_sr, WAVLM_SR).squeeze(0)
         clp_wave = torchaudio.functional.resample(waveform, orig_sr, CLAP_SR).squeeze(0)
 
         wavlm_samples = WAVLM_SR * 15
         clap_samples = CLAP_SR * 15
 
-        # Chunk generation for robust global representation
         wlm_chunks = [wlm_wave[i:i+wavlm_samples].numpy() for i in range(0, len(wlm_wave), wavlm_samples) if len(wlm_wave[i:i+wavlm_samples]) > WAVLM_SR]
         clp_chunks = [clp_wave[i:i+clap_samples].numpy() for i in range(0, len(clp_wave), clap_samples) if len(clp_wave[i:i+clap_samples]) > CLAP_SR]
         
@@ -167,35 +161,29 @@ def analyze_track(audio_path, lyrics_input):
                 il_list.append(il.cpu())
                 tl_list.append(tl.cpu())
 
-        # Extract pure raw logits
         raw_el = torch.cat(el_list, dim=0).mean(dim=0, keepdim=True)
         raw_vl = torch.cat(vl_list, dim=0).mean(dim=0, keepdim=True)
         raw_il = torch.cat(il_list, dim=0).mean(dim=0, keepdim=True)
         raw_tl = torch.cat(tl_list, dim=0).mean(dim=0, keepdim=True)
 
-        # Apply Dynamic Scaling Variance to break uniform logit binding
-        logit_std = raw_el.std(dim=-1, keepdim=True).clamp(min=1e-6)
-        scaled_el = raw_el / logit_std
+        # Enforce highly competitive soft-scaling for audio emotion logits
+        scaled_el = raw_el / raw_el.std(dim=-1, keepdim=True).clamp(min=1e-6)
+        probs_el_audio = F.softmax(scaled_el / 0.3, dim=-1).squeeze().numpy()
         
-        # Softmax over Multi-label head to strictly enforce logit class competition
-        probs_el = F.softmax(scaled_el / 1.5, dim=-1).squeeze().numpy()
-        
-        # Vibe, Intensity, Tempo strictly evaluated as Softmax (Single-label exclusivity)
         probs_vl = F.softmax(raw_vl, dim=-1).squeeze().numpy()
         probs_il = F.softmax(raw_il, dim=-1).squeeze().numpy()
         probs_tl = F.softmax(raw_tl, dim=-1).squeeze().numpy()
 
-        res_emo_raw = {EMO_LABELS[i]: float(probs_el[i]) for i in range(len(EMO_LABELS))}
+        res_emo_raw = {EMO_LABELS[i]: float(probs_el_audio[i]) for i in range(len(EMO_LABELS))}
         res_vibe = {VIBE_LABELS[i]: float(probs_vl[i]) for i in range(len(VIBE_LABELS))}
         res_int = {INTENSITY_LABELS[i]: float(probs_il[i]) for i in range(len(INTENSITY_LABELS))}
         res_tmp = {TEMPO_LABELS[i]: float(probs_tl[i]) for i in range(len(TEMPO_LABELS))}
 
-        # Sort and truncate dicts for UI presentation
         res_vibe = dict(sorted(res_vibe.items(), key=lambda x: x[1], reverse=True)[:3])
         res_int = dict(sorted(res_int.items(), key=lambda x: x[1], reverse=True)[:3])
         res_tmp = dict(sorted(res_tmp.items(), key=lambda x: x[1], reverse=True)[:3])
 
-        # --- LATE FUSION PIPELINE WITH TEXT MODEL ---
+        # --- MULTIMODAL LATE FUSION ENGAGEMENT ---
         if has_lyrics:
             t_in = tokenizer(str(lyrics_input), truncation=True, padding=True, max_length=256, return_tensors="pt").to(DEVICE)
             with torch.no_grad():
@@ -205,10 +193,10 @@ def analyze_track(audio_path, lyrics_input):
             m_dict = {MBTI_LABELS[i]: float(t_mbti_probs[i]) for i in range(len(MBTI_LABELS))}
             res_mbti = dict(sorted(m_dict.items(), key=lambda x: x[1], reverse=True)[:3])
             
-            # Weighted ensemble calculation
+            # Weighted late fusion to prioritize text model for emotion taxonomy resolution
             for k in res_emo_raw.keys():
                 idx = emo2id[k]
-                res_emo_raw[k] = (res_emo_raw[k] * 0.3) + (float(t_emo_probs[idx]) * 0.7)
+                res_emo_raw[k] = (res_emo_raw[k] * 0.15) + (float(t_emo_probs[idx]) * 0.85)
             res_emo = dict(sorted(res_emo_raw.items(), key=lambda x: x[1], reverse=True)[:3])
         else:
             res_mbti = {}