Update app.py

app.py

@@ -1,13 +1,15 @@
 # app.py
 """
 Voice→Place Recommender (Streamlit / Hugging Face Spaces)
-- 日本語音声感情認識：S3PRL(HuBERT base) + HFの下流(.pt) チェックポイントを用いた推論
-- Spaces の Settings → Secrets に HF_TOKEN を設定してください
-- ffmpeg が必要（apt.txtに ffmpeg を記載）
+- 日本語音声感情認識：S3PRL(HuBERT base) + HFの下流(.ckpt)を用いてJTES(4感情)推定
+- Spaces → Settings → Secrets に HF_TOKEN（Read権限）を設定
+- 可能なら KUSHINADA_FILENAME で ckpt を明示指定（例: s3prl/result/downstream/.../dev-best.ckpt）
+- apt.txt: ffmpeg, （任意で）fonts-ipaexfont, fonts-noto-cjk
+- requirements.txt: streamlit-audiorecorder, s3prl==0.4.17, torch==2.0.1, torchaudio==2.0.2 など
 """
 
 # ===== 基本インポート =====
-import io, json, base64, random, os
+import io, base64, os, random
 import numpy as np
 import soundfile as sf
 from pydub import AudioSegment
@@ -21,29 +23,24 @@ matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 from matplotlib import rcParams
 import japanize_matplotlib
+import matplotlib.font_manager as fm
 
-# Torch / Hugging Face Hub / S3PRL
+# Torch / HF Hub / S3PRL
 import torch
 import torch.nn as nn
 from huggingface_hub import HfApi, hf_hub_download
 from s3prl.nn import S3PRLUpstream, Featurizer
 
-
-# ===== フォント設定 =====
-import matplotlib.font_manager as fm
-
-# 日本語フォントを優先（IPAexGothic → IPAGothic → Noto Sans CJK）
+# ===== フォント設定（日本語） =====
 jp_candidates = ["IPAexGothic", "IPAGothic", "Noto Sans CJK JP", "Noto Sans CJK"]
 for name in jp_candidates:
     if any(name in f.name for f in fm.fontManager.ttflist):
         rcParams["font.family"] = name
         break
 else:
-    rcParams["font.family"] = "DejaVu Sans"  # 最後の保険
-
+    rcParams["font.family"] = "DejaVu Sans"
 rcParams["axes.unicode_minus"] = False
 
-
 # ===== 架空の場所データ =====
 PLACES = [
     {"place_id":"lib_silent", "name":"無音図書館", "tags":["静けさ","集中","屋内"], "emo_key":"calm", "image":"images/lib_silent.png"},
@@ -63,33 +60,43 @@ PLACES = [
 ]
 REASON_TAGS = ["静けさ","緑","水辺","発散","創作","交流","体験","学習","屋内","屋外","没入","回復"]
 
-# ===== KUSHINADA 定義（HF の gated モデルのリポ）=====
+# ===== モデル定義 =====
 KUSHINADA_REPO = "imprt/kushinada-hubert-base-jtes-er"
 
-# ===== S3PRL 下流ヘッド（線形） =====
-class SimpleLinearHead(nn.Module):
+# ---- Downstream ヘッド（1層 or 2層MLP） ----
+class DownstreamHead(nn.Module):
     """
-    チェックポイント中の線形分類器 (W, b) を復元する簡易ヘッド。
-    入力: [B, T, H] → mean-pool → [B, H] → Linear(H, C)
+    in -> (optional proj Linear) -> (optional ReLU) -> final Linear -> logits
     """
-    def __init__(self, in_dim: int, num_classes: int, W: torch.Tensor, b: torch.Tensor):
+    def __init__(self, in_dim, out_dim, W_final, b_final, proj_W=None, proj_b=None):
         super().__init__()
-        self.pool = lambda x: x.mean(dim=1)  # 時系列平均
-        self.fc = nn.Linear(in_dim, num_classes)
+        self.proj = None
+        if proj_W is not None and proj_b is not None:
+            proj_out, proj_in = proj_W.shape  # [out, in]
+            self.proj = nn.Linear(proj_in, proj_out)
+            with torch.no_grad():
+                self.proj.weight.copy_(proj_W)
+                self.proj.bias.copy_(proj_b)
+            in_dim = proj_out  # 後段の入力次元
+        self.fc = nn.Linear(in_dim, out_dim)
         with torch.no_grad():
-            self.fc.weight.copy_(W)  # [C, H]
-            self.fc.bias.copy_(b)    # [C]
-
-    def forward(self, reps):  # reps: [B, T, H]
-        x = self.pool(reps)
+            self.fc.weight.copy_(W_final)
+            self.fc.bias.copy_(b_final)
+
+    @property
+    def expected_in(self):
+        # 入力期待次元（Featurizerからのプール後に一致させたい次元）
+        if self.proj is not None:
+            return self.proj.in_features
+        return self.fc.in_features
+
+    def forward(self, x):  # x: [B, expected_in]
+        if self.proj is not None:
+            x = self.proj(x)
+            # 学習時に非線形を挟んでいた可能性はあるが未知なので省略（必要ならnn.ReLU()等）
         return self.fc(x)
 
-# ===== KUSHINADA (S3PRL) ローダ =====
-from huggingface_hub import HfApi, hf_hub_download
-from s3prl.nn import S3PRLUpstream, Featurizer
-
-KUSHINADA_REPO = "imprt/kushinada-hubert-base-jtes-er"
-
+# ====== KUSHINADA ローダ（上流 + featurizer + 下流ヘッド構築） ======
 @st.cache_resource(show_spinner=False)
 def load_kushinada_s3prl():
     token = os.getenv("HF_TOKEN")
@@ -97,11 +104,11 @@ def load_kushinada_s3prl():
         raise RuntimeError("環境変数 HF_TOKEN が見つかりません。SpacesのSettings→Secretsで設定してください。")
 
     revision = os.getenv("KUSHINADA_REVISION", "main")
-    prefer_filename = os.getenv("KUSHINADA_FILENAME")  # 例: "s3prl/result/downstream/.../dev-best.ckpt"
+    prefer_filename = os.getenv("KUSHINADA_FILENAME", "").strip()
 
     device = "cuda" if torch.cuda.is_available() else "cpu"
 
-    # 上流 + Featurizer（最終層）
+    # 1) 上流 + Featurizer（最終層）
     upstream = S3PRLUpstream("hubert_base").to(device).eval()
     try:
         featurizer = Featurizer(upstream)
@@ -112,110 +119,164 @@ def load_kushinada_s3prl():
             featurizer = Featurizer(upstream, feature_selection="last_hidden_state")
     featurizer = featurizer.to(device).eval()
 
-    # ckpt 選定
+    # 2) ckpt選定（下流のみ。upstream/converted系は除外）
     api = HfApi()
     info = api.model_info(KUSHINADA_REPO, token=token, revision=revision)
     all_files = [s.rfilename for s in info.siblings]
-    exts = (".pt", ".ckpt", ".pth", ".bin")
-    candidates = [f for f in all_files if f.lower().endswith(exts)]
 
+    def is_ckpt(path):
+        p = path.lower()
+        if not (p.endswith(".pt") or p.endswith(".ckpt") or p.endswith(".pth") or p.endswith(".bin")):
+            return False
+        # 上流や変換済みの類は除外
+        bad = ["upstream", "converted", "hubert_base", "s3prl/converted", "wav2vec", "espnet"]
+        if any(b in p for b in bad):
+            return False
+        return True
+
+    candidates = [f for f in all_files if is_ckpt(f)]
+
+    # 優先順位: 明示指定 > downstream/dev-best > best > fold > others
     filename = None
     if prefer_filename:
+        # サブパス一致/末尾一致にも対応
         if prefer_filename in all_files:
             filename = prefer_filename
         else:
             matches = [f for f in all_files if f.endswith(prefer_filename)]
-            if matches: filename = matches[0]
+            if matches:
+                filename = matches[0]
     if filename is None and candidates:
-        candidates = sorted(
-            candidates,
-            key=lambda f: (
-                -int(any(k in f.lower() for k in ["downstream","classifier","jtes","kushinada","dev-best","best"])),
-                len(f)
-            )
-        )
-        filename = candidates[0] if candidates else None
+        def rank_score(f):
+            f_lower = f.lower()
+            score = 0
+            if "result/downstream" in f_lower: score += 100
+            if "dev-best" in f_lower: score += 50
+            if "best" in f_lower: score += 20
+            if "fold" in f_lower: score += 10
+            if "kushinada" in f_lower: score += 5
+            return -score, len(f)  # スコア高→優先、短すぎる名前は避けたいので長さも加味
+        candidates_sorted = sorted(candidates, key=rank_score)
+        filename = candidates_sorted[0]
     if filename is None:
-        raise FileNotFoundError("下流チェックポイント(.pt/.ckpt/.pth/.bin)が見つかりません。KUSHINADA_FILENAME を Secrets に指定してください。")
+        raise FileNotFoundError("下流チェックポイントが見つかりません。KUSHINADA_FILENAME を Secrets に設定してください。")
 
     ckpt_path = hf_hub_download(
-        repo_id=KUSHINADA_REPO, filename=filename, revision=revision,
-        token=token, repo_type="model", local_dir_use_symlinks=False
+        repo_id=KUSHINADA_REPO,
+        filename=filename,
+        revision=revision,
+        token=token,
+        repo_type="model",
+        local_dir_use_symlinks=False
     )
     ckpt = torch.load(ckpt_path, map_location="cpu")
 
-    # state_dict 取得
+    # 3) state_dict 取得
     state = None
     if isinstance(ckpt, dict):
-        for key in ["state_dict","Downstream","model","downstream","net","weights"]:
+        for key in ["state_dict", "Downstream", "model", "downstream", "net", "weights"]:
             if key in ckpt and isinstance(ckpt[key], dict):
                 state = ckpt[key]; break
-        if state is None: state = ckpt
+        if state is None:
+            state = ckpt
     if not isinstance(state, dict):
         raise RuntimeError("チェックポイント形式を解釈できませんでした。")
 
-    # --- 最終分類層 (bias 長さが小さい層) を探索し、Wの向きを揃える ---
-    clf = []
+    # 4) すべての (weight,bias) の線形層候補を収集（[out,in]に整形）
+    layers = []
     for k, v in state.items():
-        if isinstance(v, torch.Tensor) and v.ndim == 1:
-            C = v.numel()
-            if 2 <= C <= 16:  # JTES は通常 4 クラス
-                # 重み候補キー
-                prefix = k[:-5] if k.endswith(".bias") else k.rsplit(".", 1)[0]
-                cand_keys = [prefix + ".weight", k.replace(".bias",".weight"), k.replace("bias","weight")]
-                for wk in cand_keys:
-                    W = state.get(wk, None)
-                    if isinstance(W, torch.Tensor) and W.ndim == 2:
-                        # 形状を [C, H] に正規化
-                        if W.shape[0] == C:
-                            oriented_W, H = W.float(), W.shape[1]
-                        elif W.shape[1] == C:
-                            oriented_W, H = W.t().float(), W.shape[0]
-                        else:
-                            continue
-                        clf.append((k, wk, C, H, oriented_W, v.float()))
-                        break
-
-    if not clf:
-        raise RuntimeError("最終分類層の重みが見つかりません（bias サイズ 2〜16 の層が見当たりません）。")
-
-    # H が 768 に近いものを優先
-    clf.sort(key=lambda x: (abs(x[3]-768), -x[2]))  # (|H-768| 小さい, クラス数 大きい)
-    _, _, num_classes, hidden_dim, linear_W, linear_b = clf[0]
-
-    head = SimpleLinearHead(in_dim=hidden_dim, num_classes=num_classes,
-                            W=linear_W, b=linear_b).to(device).eval()
-
-    default_labels = ["angry","happy","neutral","sad"]
-    id2label = {i: (default_labels[i] if num_classes == 4 and i < 4 else f"class_{i}") for i in range(num_classes)}
-
-    st.info(f"✅ 使うチェックポイント: `{filename}`（revision: {revision}）")
-    st.info(f"✅ 分類器 in_features={hidden_dim}, classes={num_classes}")
+        if isinstance(v, torch.Tensor) and v.ndim == 1:  # bias
+            b = v.float()
+            base = k[:-5] if k.endswith(".bias") else k.rsplit(".", 1)[0]
+            w_key = base + ".weight"
+            if w_key in state and isinstance(state[w_key], torch.Tensor) and state[w_key].ndim == 2:
+                W = state[w_key].float()
+                # [out, in] に整形
+                if W.shape[0] >= 2 and W.shape[1] >= 2:
+                    out, in_ = W.shape
+                    layers.append({
+                        "name": base,
+                        "W": W, "b": b,
+                        "out": out, "in": in_
+                    })
+                else:
+                    # 逆向きの可能性 [in,out] を考慮
+                    Wt = W.t()
+                    out, in_ = Wt.shape
+                    layers.append({
+                        "name": base,
+                        "W": Wt, "b": b,
+                        "out": out, "in": in_
+                    })
+
+    if not layers:
+        raise RuntimeError("線形層の (weight, bias) が見つかりませんでした。")
+
+    # 5) 最終層候補（出力クラスが小さい層を優先）
+    finals = [L for L in layers if 2 <= L["out"] <= 16]
+    if not finals:
+        raise RuntimeError("最終分類層らしき小クラス数の線形層が見つかりませんでした。")
+
+    # 768や256がよく使われるので、それに近いinを優先。名前でclassifier等があればさらに加点
+    def final_rank(L):
+        score = 0
+        if "class" in L["name"].lower() or "out" in L["name"].lower() or "fc" in L["name"].lower():
+            score += 3
+        score -= abs(L["in"] - 256) / 256.0
+        score -= abs(L["in"] - 768) / 768.0
+        return -score
+    finals_sorted = sorted(finals, key=final_rank)
+    final = finals_sorted[0]
+
+    # 6) 前段の射影（final.in に一致する out を持つ層）を探索
+    proj = None
+    proj_candidates = [L for L in layers if L["out"] == final["in"]]
+    if proj_candidates:
+        def proj_rank(L):
+            score = 0
+            if "proj" in L["name"].lower() or "linear" in L["name"].lower() or "fc" in L["name"].lower():
+                score += 2
+            score -= abs(L["in"] - 768) / 768.0
+            return -score
+        proj = sorted(proj_candidates, key=proj_rank)[0]
+
+    # 7) DownstreamHead 構築
+    if proj is not None:
+        head = DownstreamHead(
+            in_dim=proj["in"], out_dim=final["out"],
+            W_final=final["W"], b_final=final["b"],
+            proj_W=proj["W"], proj_b=proj["b"]
+        )
+    else:
+        head = DownstreamHead(
+            in_dim=final["in"], out_dim=final["out"],
+            W_final=final["W"], b_final=final["b"]
+        )
+    head = head.to(device).eval()
+
+    # 8) ラベル（JTES想定）
+    default_labels = ["angry", "happy", "neutral", "sad"]
+    id2label = {i: (default_labels[i] if head.fc.out_features == 4 and i < 4 else f"class_{i}") for i in range(head.fc.out_features)}
+
+    st.info(f"✅ ckpt: `{filename}`（rev: {revision}）")
+    st.info(f"✅ head.expected_in={head.expected_in}, final_out={head.fc.out_features}")
     return featurizer, head, id2label, device
 
 # ===== ユーティリティ =====
 def to_wav_bytes(any_bytes: bytes, target_sr=16000, mono=True) -> bytes:
-    """任意音声をWAV(16kHz/mono)へ変換"""
     if not any_bytes:
-        st.error("音声が空です。録音やアップロードを確認してください。")
-        st.stop()
+        st.error("音声が空です。録音やアップロードを確認してください。"); st.stop()
     try:
         seg = AudioSegment.from_file(io.BytesIO(any_bytes))
     except Exception as e:
-        st.error(f"音声読込エラー: {e}")
-        st.stop()
-    if mono:
-        seg = seg.set_channels(1)
-    if target_sr:
-        seg = seg.set_frame_rate(target_sr)
-    buf = io.BytesIO()
-    seg.export(buf, format="wav")
+        st.error(f"音声読込エラー: {e}"); st.stop()
+    if mono: seg = seg.set_channels(1)
+    if target_sr: seg = seg.set_frame_rate(target_sr)
+    buf = io.BytesIO(); seg.export(buf, format="wav")
     return buf.getvalue()
 
 def audio_player_bytes(b: bytes, mime="audio/wav"):
-    """音声プレイヤーを表示"""
-    if not b:
-        return
+    if not b: return
     b64 = base64.b64encode(b).decode("utf-8")
     st.markdown(
         f"""
@@ -226,75 +287,50 @@ def audio_player_bytes(b: bytes, mime="audio/wav"):
         unsafe_allow_html=True,
     )
 
-# ===== フォールバック用：簡易特徴量ベース =====
+# ===== フォールバック（簡易特徴量） =====
 def extract_features(y, sr):
-    """音声から簡易特徴量を抽出"""
     abs_y = np.abs(y)
     thr = 0.01 * (abs_y.max() + 1e-9)
     idx = np.where(abs_y > thr)[0]
-    if idx.size >= 2:
-        y = y[idx[0]:idx[-1]+1]
-
+    if idx.size >= 2: y = y[idx[0]:idx[-1]+1]
     energy_mean = float(np.sqrt(np.mean(y**2) + 1e-12))
-
     n = len(y)
     win = np.hanning(n) if n >= 512 else np.ones_like(y)
     y_win = y * win
-    spec = np.fft.rfft(y_win)
-    mag = np.abs(spec) + 1e-12
+    spec = np.fft.rfft(y_win); mag = np.abs(spec) + 1e-12
     freqs = np.fft.rfftfreq(len(y_win), d=1.0/sr)
     sc_mean = float((freqs * mag).sum() / mag.sum())
-
     zc = (y[:-1] * y[1:] < 0).astype(np.float32)
     zcr_mean = float(zc.mean()) if zc.size else 0.0
-
-    # F0推定（非常に簡易）
+    # 超簡易F0
     fmin, fmax = 80.0, 600.0
     if len(y) < int(sr / fmin) + 2:
         f0_est = 0.0
     else:
         corr = np.correlate(y, y, mode='full')[len(y)-1:]
-        lmin = max(1, int(sr / fmax))
-        lmax = min(len(corr) - 1, int(sr / fmin))
+        lmin = max(1, int(sr / fmax)); lmax = min(len(corr) - 1, int(sr / fmin))
         seg = corr[lmin:lmax] if lmax > lmin else np.array([])
         if seg.size > 0:
-            lag = lmin + int(np.argmax(seg))
-            f0_est = float(sr / lag) if lag > 0 else 0.0
+            lag = lmin + int(np.argmax(seg)); f0_est = float(sr / lag) if lag > 0 else 0.0
         else:
             f0_est = 0.0
-
-    return {
-        "f0_mean": float(f0_est),
-        "energy_mean": energy_mean,
-        "spec_centroid": sc_mean,
-        "zcr_mean": zcr_mean,
-        "duration": len(y)/sr
-    }
+    return {"f0_mean": float(f0_est), "energy_mean": energy_mean, "spec_centroid": sc_mean,
+            "zcr_mean": zcr_mean, "duration": len(y)/sr}
 
 def predict_emotion_features(audio_bytes):
-    """音声特徴量から感情を推定（フォールバック）"""
     wav_bytes_16k = to_wav_bytes(audio_bytes, target_sr=16000)
     y, sr = sf.read(io.BytesIO(wav_bytes_16k), dtype="float32")
     feat = extract_features(y, sr)
     f0, en, z = feat["f0_mean"], feat["energy_mean"], feat["zcr_mean"]
-
     arousal = float(np.tanh(160*en + 4*z))
     valence = float(np.tanh(((f0-170)/120) + 15*en))
-
-    if valence >= 0.22 and arousal >= 0.22:
-        label = "happiness"
-    elif valence >= 0.22 and arousal < 0.22:
-        label = "neutral"  # calm-ish
-    elif valence < 0.10 and arousal >= 0.30:
-        label = "anger"
-    elif valence < 0.10 and arousal < 0.18:
-        label = "sadness"
-    else:
-        label = "neutral"
-
+    if valence >= 0.22 and arousal >= 0.22: label = "happiness"
+    elif valence >= 0.22 and arousal < 0.22: label = "neutral"
+    elif valence < 0.10 and arousal >= 0.30: label = "anger"
+    elif valence < 0.10 and arousal < 0.18: label = "sadness"
+    else: label = "neutral"
     scores = {k: 0.0 for k in ["happiness","anger","sadness","neutral"]}
-    scores[label] = 0.7
-    scores["neutral"] += 0.3
+    scores[label] = 0.7; scores["neutral"] += 0.3
     return label, scores, "Features"
 
 # ===== AI推定（S3PRL）=====
@@ -314,92 +350,69 @@ def predict_emotion_ai(audio_bytes):
         wav_bytes_16k = to_wav_bytes(audio_bytes, target_sr=16000)
         y, sr = sf.read(io.BytesIO(wav_bytes_16k), dtype="float32")
 
+        # 30秒でカット
         max_duration = 30
         max_samples = int(sr * max_duration)
         if len(y) > max_samples:
-            y = y[:max_samples]
-            st.warning("音声が30秒を超えたため、最初の30秒のみを分析します。")
+            y = y[:max_samples]; st.warning("音声が30秒を超えたため、最初の30秒のみ分析します。")
 
+        # S3PRLは list[Tensor], list[int] を想定
         wavs = [torch.tensor(y, dtype=torch.float32)]
         wavs_len = [int(len(y))]
 
         with torch.no_grad():
-            reps, reps_len = featurizer(wavs, wavs_len)  # Tensor
+            reps, reps_len = featurizer(wavs, wavs_len)  # 期待: reps [B,T,H], reps_len list[int]
             if not isinstance(reps, torch.Tensor):
                 raise RuntimeError(f"Unexpected reps type: {type(reps)}")
-
-            # reps を [B,T,H?] or [B,H?,T] に正規化（B 次元を作る）
-            if reps.dim() == 1:      # [H]
-                reps = reps.unsqueeze(0).unsqueeze(0)  # [1,1,H]
-            elif reps.dim() == 2:    # [T,H] or [H,T]
-                # どちらでも batch 次元を付ける
-                reps = reps.unsqueeze(0)               # [1,*,*]
-            elif reps.dim() == 3:
-                pass
-            else:
+            # reps を [B,T,H] へ
+            if reps.dim() == 1: reps = reps.unsqueeze(0).unsqueeze(0)
+            elif reps.dim() == 2: reps = reps.unsqueeze(0)
+            elif reps.dim() != 3:
                 raise RuntimeError(f"Unexpected reps.dim(): {reps.dim()}")
 
-            B, D1, D2 = reps.shape
-            expected_H = head.fc.in_features
-
-            # reps_len 正規化
-            if reps_len is None:
-                reps_len_list = [max(D1, D2)] * B
-            elif isinstance(reps_len, int):
-                reps_len_list = [int(reps_len)] * B
-            elif isinstance(reps_len, (list, tuple)):
-                reps_len_list = [int(x) for x in reps_len]
-                if len(reps_len_list) != B: reps_len_list = [max(D1, D2)] * B
-            elif isinstance(reps_len, torch.Tensor):
-                reps_len_list = reps_len.view(-1).tolist()
-                if len(reps_len_list) != B: reps_len_list = [max(D1, D2)] * B
+            B, T, H = reps.shape
+
+            # reps_len を [B] リストに
+            if reps_len is None: reps_len_list = [T]*B
+            elif isinstance(reps_len, int): reps_len_list = [int(reps_len)]*B
+            elif isinstance(reps_len, (list, tuple)): reps_len_list = [int(x) for x in reps_len]
+            elif isinstance(reps_len, torch.Tensor): reps_len_list = reps_len.view(-1).tolist()
+            else: reps_len_list = [T]*B
+            if len(reps_len_list) != B: reps_len_list = [T]*B
+            reps_len_list = [max(1, min(int(li), T)) for li in reps_len_list]
+
+            # 有効長で時間平均 → [B,H_feat]
+            pooled = torch.stack([reps[i, :reps_len_list[i]].mean(dim=0) for i in range(B)], dim=0)  # [B,H_feat]
+
+            # 次元整合：期待入力に合わせる
+            expected_in = head.expected_in
+            H_feat = pooled.shape[1]
+
+            if H_feat == expected_in:
+                pooled_in = pooled
+            elif H_feat % expected_in == 0:
+                g = H_feat // expected_in
+                pooled_in = pooled.view(B, expected_in, g).mean(dim=2)  # グループ平均で縮約
+                st.info(f"ℹ️ 特徴次元を {H_feat}→{expected_in} にグループ平均で整合 (group={g})")
             else:
-                reps_len_list = [max(D1, D2)] * B
-
-            # --- 特徴次元の自動判定＆時間平均 ---
-            def pool_over_time(tensor3d, time_dim):
-                # time_dim: 1 or 2
-                pooled = []
-                for i in range(tensor3d.shape[0]):
-                    Ti = min(max(1, reps_len_list[i]), tensor3d.shape[time_dim])
-                    if time_dim == 1:
-                        pooled.append(tensor3d[i, :Ti].mean(dim=0))  # [H]
-                    else:
-                        pooled.append(tensor3d[i, :, :Ti].mean(dim=1))  # [H]
-                return torch.stack(pooled, dim=0)  # [B,H]
-
-            if D2 == expected_H:
-                pooled = pool_over_time(reps, time_dim=1)  # [B,H]
-            elif D1 == expected_H:
-                pooled = pool_over_time(reps, time_dim=2)  # [B,H]
-            else:
-                # どの軸も一致しない: 割り切れれば再整形して H を作る
-                if D2 % expected_H == 0:
-                    k = D2 // expected_H
-                    reps2 = reps.view(B, D1, expected_H, k).mean(dim=3)  # [B,D1,H]
-                    pooled = pool_over_time(reps2, time_dim=1)
-                elif D1 % expected_H == 0:
-                    k = D1 // expected_H
-                    reps2 = reps.view(B, expected_H, k, D2).mean(dim=2)  # [B,H,D2]
-                    pooled = pool_over_time(reps2, time_dim=2)
-                else:
-                    raise RuntimeError(f"特徴次元が一致しません: reps.shape={tuple(reps.shape)}, 期待H={expected_H}")
-
-            logits = head.fc(pooled.to(device))       # [B,C]
+                # どうしても合わない場合は線形射影（最小限の適合用）
+                proj = nn.Linear(H_feat, expected_in).to(pooled.device)
+                with torch.no_grad():
+                    nn.init.eye_(proj.weight[:min(H_feat, expected_in), :min(H_feat, expected_in)])
+                    if expected_in > H_feat:
+                        nn.init.zeros_(proj.weight[min(H_feat, expected_in):])
+                    nn.init.zeros_(proj.bias)
+                pooled_in = proj(pooled)
+                st.info(f"ℹ️ 線形射影で {H_feat}→{expected_in} に適合")
+
+            logits = head(pooled_in.to(device))      # [B,C]
             probs = torch.softmax(logits, dim=-1)[0].detach().cpu().numpy()
 
         pred_id = int(np.argmax(probs))
         raw_label = id2label[pred_id]
-
-        def _norm(lbl: str) -> str:
-            m = {"happy":"happiness", "angry":"anger", "sad":"sadness", "neutral":"neutral"}
-            return m.get(lbl.lower(), lbl)
-
-        label = _norm(raw_label)
-        scores = {_norm(id2label[i]): float(probs[i]) for i in range(len(probs))}
-        for k in list(scores.keys()):
-            scores[k] = max(0.0, min(1.0, scores[k]))
-
+        label = _normalize_label(raw_label)
+        scores = {_normalize_label(id2label[i]): float(probs[i]) for i in range(len(probs))}
+        for k in list(scores.keys()): scores[k] = max(0.0, min(1.0, scores[k]))
         return label, scores, "AI(S3PRL)"
 
     except Exception as e:
@@ -413,10 +426,8 @@ def score_places(emo_label, top_k=4, diversity=True):
         "anger": ["release", "calm"],
         "sadness": ["calm", "joy"],
         "neutral": ["calm", "surprise", "joy"],
-        "joy": ["joy","surprise"],
-        "calm": ["calm","joy"],
-        "surprise": ["surprise","joy"],
-        "release": ["release","calm"],
+        "joy": ["joy","surprise"], "calm": ["calm","joy"],
+        "surprise": ["surprise","joy"], "release": ["release","calm"],
     }
     priors = EMO_MAP_PRIORS.get(emo_label, ["calm","joy","surprise"])
     scored = []
@@ -427,63 +438,38 @@ def score_places(emo_label, top_k=4, diversity=True):
         scored.append((base + random.uniform(-0.02, 0.02), p))
     scored.sort(key=lambda x: x[0], reverse=True)
     candidates = [p for _, p in scored[:max(top_k, 4)]]
-
-    if not diversity:
-        return candidates[:top_k]
-
+    if not diversity: return candidates[:top_k]
     picked, seen = [], set()
     for p in candidates:
-        k = p["emo_key"]
-        if k not in seen:
-            picked.append(p); seen.add(k)
-        if len(picked) >= top_k:
-            break
+        if p["emo_key"] not in seen:
+            picked.append(p); seen.add(p["emo_key"])
+        if len(picked) >= top_k: break
     if len(picked) < top_k:
         for p in candidates:
-            if p not in picked:
-                picked.append(p)
-            if len(picked) >= top_k:
-                break
+            if p not in picked: picked.append(p)
+            if len(picked) >= top_k: break
     return picked
 
 # ===== 可視化 =====
 def plot_emotion_map(emotion_label, scores, method="AI"):
     fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5), dpi=150)
-
     emotion_jp = {
-        'happiness': '😊 喜び',
-        'anger': '😠 怒り',
-        'sadness': '😢 悲しみ',
-        'neutral': '😐 中立',
-        'joy': '😊 喜び',
-        'calm': '😌 落ち着き',
-        'surprise': '😲 驚き',
-        'release': '💨 発散'
+        'happiness': '😊 喜び', 'anger': '😠 怒り', 'sadness': '😢 悲しみ', 'neutral': '😐 中立',
+        'joy': '😊 喜び', 'calm': '😌 落ち着き', 'surprise': '😲 驚き', 'release': '💨 発散'
     }
     color_map = {
-        'happiness': '#FF6B6B',
-        'anger': '#FFA94D',
-        'sadness': '#868E96',
-        'neutral': '#51CF66',
-        'joy': '#FF6B6B',
-        'calm': '#51CF66',
-        'surprise': '#74C0FC',
-        'release': '#FFD43B'
+        'happiness': '#FF6B6B','anger': '#FFA94D','sadness': '#868E96','neutral': '#51CF66',
+        'joy': '#FF6B6B','calm': '#51CF66','surprise': '#74C0FC','release': '#FFD43B'
     }
-
-    labels = list(scores.keys())
-    values = [scores[k] for k in labels]
+    labels = list(scores.keys()); values = [scores[k] for k in labels]
     colors = [color_map.get(k, '#74C0FC') for k in labels]
     bars = ax1.bar([emotion_jp.get(k,k) for k in labels], values, color=colors, alpha=0.85)
-    ax1.set_ylim(0, 1)
-    ax1.set_ylabel('Score', fontsize=12)
+    ax1.set_ylim(0, 1); ax1.set_ylabel('Score', fontsize=12)
     ax1.set_title(f'Emotion Scores ({method})', fontsize=14, fontweight='bold')
     ax1.grid(axis='y', alpha=0.3)
-    for bar, value in zip(bars, values):
+    for bar, v in zip(bars, values):
         ax1.text(bar.get_x() + bar.get_width()/2., bar.get_height() + 0.01,
-                 f'{value:.2f}', ha='center', va='bottom', fontsize=10)
-
-    # 円グラフ（0.05未満は非表示）
+                 f'{v:.2f}', ha='center', va='bottom', fontsize=10)
     pairs = [(k,v) for k,v in scores.items() if v > 0.05]
     sizes = [v for _,v in pairs]
     labels_pie = [emotion_jp.get(k,k) for k,_ in pairs]
@@ -492,9 +478,7 @@ def plot_emotion_map(emotion_label, scores, method="AI"):
             autopct='%1.0f%%', startangle=90, textprops={'fontsize': 11})
     ax2.set_title(f'Result: {emotion_jp.get(emotion_label, emotion_label)}',
                   fontsize=14, fontweight='bold')
-
-    plt.tight_layout()
-    return fig
+    plt.tight_layout(); return fig
 
 # ===== メイン =====
 def main():
@@ -510,7 +494,7 @@ def main():
         if key not in st.session_state: st.session_state[key] = default
 
     st.subheader("1) 録音またはアップロード")
-    with st.warning("⚠️ ファイルアップロードで403が出る場合��、録音機能をご利用ください。"):
+    with st.warning("⚠️ アップロードで403が出る場合は、録音機能をご利用ください。"):
         st.markdown("**🎤 録音** → 直接話す or 端末で音声再生しながら録音")
 
     tab_rec, tab_upload = st.tabs(["🎤 録音する（推奨）", "📁 ファイルを使う"])
@@ -522,18 +506,14 @@ def main():
             st.session_state["wav_bytes"] = buf.getvalue()
             audio_player_bytes(st.session_state["wav_bytes"], mime="audio/wav")
             st.caption(f"録音サイズ: {len(st.session_state['wav_bytes']) / 1024:.1f} KB")
-
         if st.button("🧹 クリアして新しく録音", width="stretch"):
             for k in ["wav_bytes","recs","feat","emotion_label","scores","method"]:
                 st.session_state[k] = None
-            st.session_state["rec_key"] += 1
-            st.rerun()
+            st.session_state["rec_key"] += 1; st.rerun()
 
     with tab_upload:
         uploaded_file = st.file_uploader(
-            "音声ファイルを選択（WAV推奨）",
-            type=["wav", "mp3", "m4a"],
-            accept_multiple_files=False
+            "音声ファイルを選択（WAV推奨）", type=["wav", "mp3", "m4a"], accept_multiple_files=False
         )
         if uploaded_file is not None:
             try:
@@ -543,8 +523,7 @@ def main():
                 st.caption(f"ファイルサイズ: {len(bytes_data) / 1024:.1f} KB")
                 audio_player_bytes(bytes_data, mime="audio/wav")
             except Exception as e:
-                st.error("❌ ファイル読み込みエラー")
-                st.exception(e)
+                st.error("❌ ファイル読み込みエラー"); st.exception(e)
                 st.info("💡 代わりに録音機能をお試しください。")
 
     st.subheader("2) 同意")
@@ -552,9 +531,7 @@ def main():
                        ["保存しない（体験のみ）", "匿名で保存する"], horizontal=True)
     save_audio = st.checkbox("音声ファイルも保存する（任意）", value=False)
 
-    analysis_method = st.radio("分析方法",
-                               ["AIモデル（推奨）", "音声特徴量ベース"],
-                               horizontal=True)
+    analysis_method = st.radio("分析方法", ["AIモデル（推奨）", "音声特徴量ベース"], horizontal=True)
 
     if st.button("🔍 推定 & レコメンド", type="primary", width="stretch",
                  disabled=(st.session_state["wav_bytes"] is None)):
@@ -564,12 +541,10 @@ def main():
                 emotion_label, scores, method = predict_emotion_ai(raw_bytes)
             else:
                 emotion_label, scores, method = predict_emotion_features(raw_bytes)
-
             st.session_state["emotion_label"] = emotion_label
             st.session_state["scores"] = scores
             st.session_state["method"] = method
             st.session_state["recs"] = score_places(emotion_label, top_k=4, diversity=True)
-
         st.success("分析が完了しました！")
 
     if st.session_state["recs"] is not None:
@@ -577,7 +552,6 @@ def main():
         scores = st.session_state["scores"]
         method = st.session_state["method"]
         recs = st.session_state["recs"]
-
         emotion_japanese = {
             'happiness': '喜び', 'anger': '怒り', 'sadness': '悲しみ', 'neutral': '中立',
             'joy': '喜び', 'calm': '落ち着き', 'surprise': '驚き', 'release': '発散'
@@ -606,10 +580,8 @@ def main():
         cols = st.columns(4)
         for i, p in enumerate(recs[:4]):
             with cols[i % 4]:
-                if "image" in p:
-                    st.image(p["image"], width="stretch")
-                st.markdown(f"**{p['name']}**")
-                st.caption(f"タグ: {', '.join(p['tags'])}")
+                if "image" in p: st.image(p["image"], width="stretch")
+                st.markdown(f"**{p['name']}**"); st.caption(f"タグ: {', '.join(p['tags'])}")
 
         st.subheader("4) 評価")
         choice_name = st.selectbox("第一候補を選んでください", [p["name"] for p in recs[:4]])
@@ -617,20 +589,16 @@ def main():
         rating_vibe = st.slider("気分に合う度（🎯）", 1, 5, 4)
         reasons = st.multiselect("理由タグ（1–3個）", REASON_TAGS, max_selections=3)
         comment = st.text_input("ひとことコメント（任意・20字）", max_chars=20)
-
         if st.button("💾 ログ保存", width="stretch"):
             consent_research = (consent == "匿名で保存する")
-            if not consent_research:
-                st.info("体験のみモードです。研究ログは保存しません。")
-            else:
-                st.success("保存機能は開発中です。")
+            if not consent_research: st.info("体験のみモードです。研究ログは保存しません。")
+            else: st.success("保存機能は開発中です。")
 
     st.divider()
     if st.button("▶ 次の人を録音する（状態をクリ���）", width="stretch"):
         for k in ["wav_bytes","recs","emotion_label","scores","method"]:
             st.session_state[k] = None
-        st.session_state["rec_key"] += 1
-        st.rerun()
+        st.session_state["rec_key"] += 1; st.rerun()
 
 if __name__ == "__main__":
     main()