コード進行からジャズの楽曲を検索するシステムを作ってみた

【データ登録】

  曲のコード進行データを用意
       ↓
  パーサー（テキスト → 構造化データ）
       ↓
  各拍にコードを割り当て
       ↓
  一定の小節数ごとにブロックに分割
       ↓
  各ブロックを512次元ベクトルに変換
       ↓
  PostgreSQL + pgvector に格納・HNSWインデックス作成

【検索時】

  ユーザーがコードを入力
       ↓
  パーサー → 各拍にコードを割り当て
       ↓
  データ登録時と同じルールでブロックに分割
       ↓
  各ブロックを12キーに移調 & ネガティブハーモニー変換でクエリ作成
  （例: 1ブロック → 12移調 × 2（原形+ネガティブハーモニー） = 24クエリ）
       ↓
  pgvector でコサイン類似度検索（24クエリ並列実行）
       ↓
  類似度順にソートして結果を返す

function rootCircleOfFifths(root: number): number[] {
  const pos = FIFTHS_POSITION[root]; // C=0, G=1, D=2, ...
  const angle = (2 * Math.PI * pos) / 12;
  const v: number[] = [];
  for (let h = 1; h <= 6; h++) {
    v.push(Math.sin(h * angle));
    v.push(Math.cos(h * angle));
  }
  return v;
}

function selectWindowSize(queryBars: number): number {
  if (queryBars <= 6) return 4;
  if (queryBars <= 12) return 8;
  return 16;
}

CREATE INDEX song_segments_bc4_idx ON song_segments
  USING hnsw (embedding vector_cosine_ops)
  WHERE bar_count = 4;

 [Dm7, G7, Cmaj7, A7]
→ (vec(Dm7) + vec(G7) + vec(Cmaj7) + vec(A7)) / 4
→ 128次元ベクトル

avg(Dm7, G7, Cmaj7, A7) = avg(G7, Dm7, A7, Cmaj7)

ブロック [Dm7 | G7 | Cmaj7 | A7]  （4小節）
            ↓
  Group 0: vec(Dm7)     → 128次元
  Group 1: vec(G7)      → 128次元
  Group 2: vec(Cmaj7)   → 128次元
  Group 3: vec(A7)      → 128次元
            ↓
  連結 → [Group0, Group1, Group2, Group3] = 512次元
            ↓
  L2正規化

export function generateEmbedding(
  events: BeatEvent[],
  barCount?: number,
): number[] {
  const expanded = expandBeats(events);
  const bars = barCount ?? Math.max(...expanded.map((b) => b.bar)) + 1;
  const barsPerGroup = bars / SEGMENT_GROUPS; // SEGMENT_GROUPS = 4

  const groups = Array.from({ length: SEGMENT_GROUPS }, () =>
    new Array(CHORD_DIM).fill(0),
  );
  const counts = new Array(SEGMENT_GROUPS).fill(0);

  for (const beat of expanded) {
    const g = Math.min(Math.floor(beat.bar / barsPerGroup), SEGMENT_GROUPS - 1);
    const vec = chordToVector128(beat.chord);
    for (let i = 0; i < CHORD_DIM; i++) groups[g][i] += vec[i];
    counts[g]++;
  }

  const result: number[] = [];
  for (let g = 0; g < SEGMENT_GROUPS; g++) {
    if (counts[g] > 0) {
      for (let i = 0; i < CHORD_DIM; i++) groups[g][i] /= counts[g];
    }
    result.push(...groups[g]);
  }
  return l2Normalize(result); // 512次元
}

Group 0: bar 0, 1       ← 2小節
Group 1: bar 2          ← 1小節
Group 2: bar 3, 4       ← 2小節
Group 3: bar 5          ← 1小節

Group 0: bar 0    ← 1小節
Group 1: bar 1    ← 1小節
Group 2: bar 2    ← 1小節
Group 3: bar 3    ← 1小節

6小節の入力 → 4小節ずつ、2小節ずらし
  ブロック1: 1〜4小節目 → ベクトル化して検索
  ブロック2: 3〜6小節目 → ベクトル化して検索

p' = (2K + 7 - p) mod 12

Cmaj7の構成音 {C, E, G, B}
  → 各音を反転 → {G, Eb, C, Ab}
  → コード同定 → Abmaj7

// 入力をDB登録時と同じルールで切り分ける
const step = windowSize / 2;
const windows: BeatEvent[][] = [];
for (let start = 0; start + windowSize <= queryBars; start += step) {
  const winEvents = events
    .filter((e) => e.bar >= start && e.bar < start + windowSize)
    .map((e) => ({ ...e, bar: e.bar - start }));
  if (winEvents.length > 0) windows.push(winEvents);
}
if (windows.length === 0) windows.push(events);

// 各ブロック × 12キー × 2（原形＋ネガティブハーモニー版）をすべてベクトル化
const embeddings: number[][] = [];
for (const winEvents of windows) {
  for (let semitones = 0; semitones < 12; semitones++) {
    const transposed =
      semitones === 0 ? winEvents : transposeEvents(winEvents, semitones);
    embeddings.push(generateEmbedding(transposed, windowSize));

    const key = detectKey(transposed);
    const nh = negativeHarmonyEvents(transposed, key);
    embeddings.push(generateEmbedding(nh, windowSize));
  }
}
const allResults = await searchSegmentsMulti(embeddings, windowSize, limit);

const bestPerSong = new Map<string, SegmentSearchResult>();
for (const results of allResults) {
  for (const r of results) {
    const existing = bestPerSong.get(r.songId);
    if (!existing || r.score > existing.score) {
      bestPerSong.set(r.songId, r);
    }
  }
}