Add internal-meetings pipeline and post-hoc speaker tools
This commit is contained in:
Keysat
@@ -0,0 +1,624 @@
|
||||
// Cross-chunk speaker reconciliation for Phase 1D of the diarization
|
||||
// pipeline. Spark Control's /api/audio/diarize-chunk hands back
|
||||
// per-chunk speaker labels ("Speaker_0", "Speaker_1") that are local
|
||||
// to one chunk — Sortformer has no memory across calls, so Speaker_0
|
||||
// in chunk 5 might or might not be the same person as Speaker_0 in
|
||||
// chunk 6. The per-speaker 192-dim TitaNet voice embedding it also
|
||||
// returns IS persistent though, so we cluster fingerprints across
|
||||
// chunks via cosine similarity to recover the global speaker identity.
|
||||
//
|
||||
// Algorithm: average-linkage agglomerative clustering. Start with N
|
||||
// singleton clusters (one per fingerprint), repeatedly merge the
|
||||
// closest pair until no pair is closer than the operator-configured
|
||||
// threshold. Average-linkage was the choice over single/complete
|
||||
// because it's robust to outlier embeddings (one bad embedding from
|
||||
// a noisy chunk doesn't anchor or repel an entire cluster).
|
||||
//
|
||||
// Complexity: O(N³) where N = total fingerprints across all chunks.
|
||||
// Typical: 2 speakers × 21 chunks = 42 → ~74k ops, sub-millisecond.
|
||||
// Worst case for a 4-hour all-talk-show video: 6 speakers × 48 chunks
|
||||
// = ~288 → ~24M ops, still milliseconds in Node.
|
||||
//
|
||||
// Threshold convention: configured as INTEGER percentage 50-95
|
||||
// representing cosine similarity. 70 (= 0.70 sim) is NeMo's
|
||||
// recommended default for TitaNet embeddings. Internally we work
|
||||
// in cosine DISTANCE (= 1 - similarity) for the merge condition.
|
||||
|
||||
// ─── Cosine similarity ──────────────────────────────────────────────
|
||||
// Standard dot-product / (||a|| * ||b||). Both inputs must be number
|
||||
// arrays of the same length. Returns 0 for any zero-magnitude input
|
||||
// to avoid NaN propagation.
|
||||
export function cosineSimilarity(a, b) {
|
||||
if (!a || !b || a.length !== b.length) return 0;
|
||||
let dot = 0;
|
||||
let na = 0;
|
||||
let nb = 0;
|
||||
for (let i = 0; i < a.length; i++) {
|
||||
dot += a[i] * b[i];
|
||||
na += a[i] * a[i];
|
||||
nb += b[i] * b[i];
|
||||
}
|
||||
if (!na || !nb) return 0;
|
||||
return dot / (Math.sqrt(na) * Math.sqrt(nb));
|
||||
}
|
||||
|
||||
// ─── Cluster ID naming ──────────────────────────────────────────────
|
||||
// Speaker_A, Speaker_B, ..., Speaker_Z, Speaker_AA, Speaker_AB...
|
||||
// Capital letter prefix is intentionally distinct from the chunk-
|
||||
// local "Speaker_0" / "Speaker_1" naming that Sortformer uses, so
|
||||
// the source of a label is obvious at a glance.
|
||||
function globalSpeakerLabel(index) {
|
||||
let n = index;
|
||||
let s = "";
|
||||
do {
|
||||
s = String.fromCharCode(65 + (n % 26)) + s;
|
||||
n = Math.floor(n / 26) - 1;
|
||||
} while (n >= 0);
|
||||
return "Speaker_" + s;
|
||||
}
|
||||
|
||||
// ─── Agglomerative clustering (average linkage) ─────────────────────
|
||||
// Input: array of { key, vector } pairs. `key` is opaque to the
|
||||
// algorithm — we just propagate it into the returned cluster's
|
||||
// `members` list for the caller to map back to (chunkIdx, localLabel).
|
||||
//
|
||||
// Output: array of clusters, each { members: [keys], vectors: [vecs] }.
|
||||
// Order: clusters are emitted in the order their FIRST member was
|
||||
// added to the input — keeps "Speaker_A" assigned to whoever spoke
|
||||
// first across the audio, which is the natural user expectation.
|
||||
function agglomerativeCluster(items, distanceThreshold) {
|
||||
if (items.length === 0) return [];
|
||||
const clusters = items.map((it) => ({
|
||||
members: [it.key],
|
||||
vectors: [it.vector],
|
||||
firstOrder: it.firstOrder, // preserve original input order for stable sort later
|
||||
}));
|
||||
// Cache pairwise singleton distances to avoid recomputing as
|
||||
// clusters grow. distMatrix[i][j] = avg cosine distance between
|
||||
// cluster i's vectors and cluster j's vectors. Recomputed on merge.
|
||||
while (clusters.length > 1) {
|
||||
let best = { dist: Infinity, i: -1, j: -1 };
|
||||
for (let i = 0; i < clusters.length; i++) {
|
||||
for (let j = i + 1; j < clusters.length; j++) {
|
||||
const d = avgLinkageDistance(clusters[i], clusters[j]);
|
||||
if (d < best.dist) {
|
||||
best = { dist: d, i, j };
|
||||
}
|
||||
}
|
||||
}
|
||||
if (best.dist > distanceThreshold) break;
|
||||
// Merge clusters[j] into clusters[i], remove clusters[j]
|
||||
clusters[best.i].members.push(...clusters[best.j].members);
|
||||
clusters[best.i].vectors.push(...clusters[best.j].vectors);
|
||||
// Keep the earliest firstOrder so the merged cluster sorts to
|
||||
// the position of its earliest-appearing member.
|
||||
if (clusters[best.j].firstOrder < clusters[best.i].firstOrder) {
|
||||
clusters[best.i].firstOrder = clusters[best.j].firstOrder;
|
||||
}
|
||||
clusters.splice(best.j, 1);
|
||||
}
|
||||
// Sort by first-appearance order so Speaker_A = whoever spoke first.
|
||||
clusters.sort((a, b) => a.firstOrder - b.firstOrder);
|
||||
return clusters;
|
||||
}
|
||||
|
||||
function avgLinkageDistance(c1, c2) {
|
||||
let sum = 0;
|
||||
let count = 0;
|
||||
for (const v1 of c1.vectors) {
|
||||
for (const v2 of c2.vectors) {
|
||||
sum += 1 - cosineSimilarity(v1, v2);
|
||||
count += 1;
|
||||
}
|
||||
}
|
||||
return count > 0 ? sum / count : Infinity;
|
||||
}
|
||||
|
||||
// ─── Public: cluster per-chunk diarization → global speaker map ─────
|
||||
//
|
||||
// Input shape (one entry per chunk; failed/skipped chunks are
|
||||
// silently filtered):
|
||||
// {
|
||||
// ok: true,
|
||||
// chunkIndex: 5,
|
||||
// startSeconds: 1080,
|
||||
// segments: [{ start, end, speaker_local, confidence }],
|
||||
// speakers_local: ["Speaker_0", "Speaker_1"],
|
||||
// fingerprints: { "Speaker_0": [192 floats], "Speaker_1": [192 floats] }
|
||||
// }
|
||||
//
|
||||
// Returns:
|
||||
// {
|
||||
// globalMap: Map<"chunkIdx:localLabel", "Speaker_A">,
|
||||
// speakers: {
|
||||
// Speaker_A: { turns, total_speaking_seconds, mean_confidence,
|
||||
// chunks_appeared_in, fingerprint_count },
|
||||
// ...
|
||||
// },
|
||||
// clusterCount: 2,
|
||||
// thresholdSimilarity: 0.70
|
||||
// }
|
||||
//
|
||||
// When fingerprintCount === 0 (diarization off or all chunks failed)
|
||||
// returns an empty result: { globalMap: empty, speakers: {}, ... }.
|
||||
// Post-cluster suppression tunables. After the initial agglomerative
|
||||
// cluster pass, walk the resulting clusters and re-categorize the
|
||||
// small ones to fix the "14 speakers detected when really only 2"
|
||||
// case Grant flagged on a 2h53m podcast. The clustering algorithm
|
||||
// itself stays strict (no false-positive merges); suppression is a
|
||||
// second pass that operates on cluster size + cross-cluster
|
||||
// similarity to catch the noise-induced spurious clusters.
|
||||
//
|
||||
// anchor_min_speaking_sec — a cluster needs at least this much
|
||||
// total speaking time to be considered an "anchor" (= a real
|
||||
// speaker). Anchors keep their own global ID + colored chip.
|
||||
//
|
||||
// small_cluster_max_speaking_sec — clusters with LESS than this
|
||||
// are suppression candidates. Brief utterances are common false
|
||||
// positives (background noise, crosstalk fragments, brief
|
||||
// intros).
|
||||
//
|
||||
// uncertain_margin_pct — a small cluster whose best similarity
|
||||
// to any anchor is within this many percentage points of the
|
||||
// main threshold gets REASSIGNED to that anchor and marked
|
||||
// uncertain (chip shows "?"). Far-from-anchor small clusters
|
||||
// become Speaker_Unknown.
|
||||
//
|
||||
// All three are operator-editable via Settings → Operator hardware.
|
||||
// Defaults are conservative — no false-positive merges into
|
||||
// anchors, just reassignment of small clusters that are PROBABLY
|
||||
// the anchor in noisy conditions. A real 30+ second second speaker
|
||||
// still gets their own chip; only brief flecks of similar voice get
|
||||
// pulled in.
|
||||
const DEFAULT_ANCHOR_MIN_SPEAKING_SEC = 30;
|
||||
const DEFAULT_SMALL_CLUSTER_MAX_SPEAKING_SEC = 15;
|
||||
const DEFAULT_UNCERTAIN_MARGIN_PCT = 10;
|
||||
|
||||
// Average cosine similarity between two clusters' vector sets —
|
||||
// inverse of avgLinkageDistance, expressed as similarity for
|
||||
// readability in the suppression logic.
|
||||
function avgLinkageSimilarity(c1, c2) {
|
||||
return 1 - avgLinkageDistance(c1, c2);
|
||||
}
|
||||
|
||||
// Clamp an option value to an integer in [lo, hi], falling back to
|
||||
// `fallback` when the value is missing or non-finite. Used to make
|
||||
// out-of-range or absent operator settings safe.
|
||||
function clampInt(v, fallback, lo, hi) {
|
||||
const n = Number(v);
|
||||
if (!Number.isFinite(n)) return fallback;
|
||||
const i = Math.round(n);
|
||||
if (i < lo) return lo;
|
||||
if (i > hi) return hi;
|
||||
return i;
|
||||
}
|
||||
|
||||
export function clusterSpeakers(
|
||||
chunkDiarization,
|
||||
clusterThresholdPct = 70,
|
||||
options = {}
|
||||
) {
|
||||
// Use Number.isFinite-guarded fallback rather than the `|| 70`
|
||||
// idiom — the latter substitutes 70 for ANY falsy value including
|
||||
// 0 (a valid input we want to clamp to 50, not silently bump up).
|
||||
const raw = Number(clusterThresholdPct);
|
||||
const pct = Math.max(50, Math.min(95, Number.isFinite(raw) ? raw : 70));
|
||||
const similarityThreshold = pct / 100;
|
||||
const distanceThreshold = 1 - similarityThreshold;
|
||||
|
||||
// Operator-tunable suppression thresholds — accept from options
|
||||
// with Number.isFinite-guarded fallbacks to the conservative
|
||||
// defaults. Clamped to the same ranges the admin.js SETTINGS_RANGES
|
||||
// enforces on save, so a hand-edited relay-config.json with an
|
||||
// out-of-range value still produces sane behavior.
|
||||
const anchorMinSec = clampInt(
|
||||
options.anchorMinSpeakingSec,
|
||||
DEFAULT_ANCHOR_MIN_SPEAKING_SEC,
|
||||
5,
|
||||
120
|
||||
);
|
||||
const smallMaxSec = clampInt(
|
||||
options.smallClusterMaxSpeakingSec,
|
||||
DEFAULT_SMALL_CLUSTER_MAX_SPEAKING_SEC,
|
||||
1,
|
||||
60
|
||||
);
|
||||
const uncertainMarginPct = clampInt(
|
||||
options.uncertainMarginPct,
|
||||
DEFAULT_UNCERTAIN_MARGIN_PCT,
|
||||
0,
|
||||
30
|
||||
);
|
||||
const uncertainSimThreshold = Math.max(
|
||||
0,
|
||||
similarityThreshold - uncertainMarginPct / 100
|
||||
);
|
||||
|
||||
// Flatten fingerprints into the clustering input. Preserve insertion
|
||||
// order so the first-appearance speaker gets Speaker_A.
|
||||
const items = [];
|
||||
let order = 0;
|
||||
for (const d of chunkDiarization || []) {
|
||||
if (!d || !d.ok || !d.fingerprints) continue;
|
||||
for (const [localLabel, vector] of Object.entries(d.fingerprints)) {
|
||||
if (!Array.isArray(vector) || vector.length === 0) continue;
|
||||
items.push({
|
||||
key: `${d.chunkIndex}:${localLabel}`,
|
||||
vector,
|
||||
firstOrder: order++,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (items.length === 0) {
|
||||
return {
|
||||
globalMap: new Map(),
|
||||
uncertaintyMap: new Map(),
|
||||
speakers: {},
|
||||
clusterCount: 0,
|
||||
thresholdSimilarity: similarityThreshold,
|
||||
};
|
||||
}
|
||||
|
||||
const clusters = agglomerativeCluster(items, distanceThreshold);
|
||||
|
||||
// ─── First pass: compute speaking time per cluster ───────────────
|
||||
// We need cluster sizes BEFORE building the global map so the
|
||||
// suppression pass can identify anchors. Walk all diar segments,
|
||||
// map each (chunkIdx, speaker_local) to its cluster index, and
|
||||
// accumulate seg duration.
|
||||
const clusterIdxByMember = new Map();
|
||||
for (let i = 0; i < clusters.length; i++) {
|
||||
for (const memberKey of clusters[i].members) {
|
||||
clusterIdxByMember.set(memberKey, i);
|
||||
}
|
||||
}
|
||||
const totalSecsByCluster = new Array(clusters.length).fill(0);
|
||||
for (const d of chunkDiarization || []) {
|
||||
if (!d || !d.ok || !Array.isArray(d.segments)) continue;
|
||||
for (const seg of d.segments) {
|
||||
const key = `${d.chunkIndex}:${seg.speaker_local}`;
|
||||
const ci = clusterIdxByMember.get(key);
|
||||
if (ci === undefined) continue;
|
||||
const dur = Math.max(0, (seg.end || 0) - (seg.start || 0));
|
||||
totalSecsByCluster[ci] += dur;
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Second pass: identify anchors + plan suppression ────────────
|
||||
const isAnchorIdx = new Array(clusters.length).fill(false);
|
||||
const anchorIdxs = [];
|
||||
for (let i = 0; i < clusters.length; i++) {
|
||||
if (totalSecsByCluster[i] >= anchorMinSec) {
|
||||
isAnchorIdx[i] = true;
|
||||
anchorIdxs.push(i);
|
||||
}
|
||||
}
|
||||
|
||||
// reassignTo[i] = anchor cluster idx that absorbs i; uncertain
|
||||
// unknownClusters: set of cluster idxs whose members map to
|
||||
// Speaker_Unknown. keptAsOwn: non-anchor cluster idxs that stay
|
||||
// as their own speaker (large + low-sim — plausibly a real
|
||||
// third+ speaker even if rare).
|
||||
const reassignTo = new Map();
|
||||
const unknownClusters = new Set();
|
||||
if (anchorIdxs.length >= 1) {
|
||||
for (let i = 0; i < clusters.length; i++) {
|
||||
if (isAnchorIdx[i]) continue;
|
||||
// Find best anchor by average cosine similarity
|
||||
let bestAnchorIdx = -1;
|
||||
let bestSim = -Infinity;
|
||||
for (const ai of anchorIdxs) {
|
||||
const sim = avgLinkageSimilarity(clusters[i], clusters[ai]);
|
||||
if (sim > bestSim) {
|
||||
bestSim = sim;
|
||||
bestAnchorIdx = ai;
|
||||
}
|
||||
}
|
||||
const totalSecs = totalSecsByCluster[i];
|
||||
if (bestAnchorIdx >= 0 && bestSim >= uncertainSimThreshold) {
|
||||
// Close-to-anchor (within uncertain_margin_pct of
|
||||
// main threshold) → reassign to anchor with uncertainty.
|
||||
// Chip will show e.g. "MH?" so the user knows attribution
|
||||
// is best-guess.
|
||||
reassignTo.set(i, bestAnchorIdx);
|
||||
} else if (totalSecs < smallMaxSec) {
|
||||
// Small + far-from-anchor → Unknown. Brief noise / crosstalk /
|
||||
// background voices that don't confidently match either main
|
||||
// speaker. Merged into a single Speaker_Unknown pseudo-
|
||||
// speaker so the legend doesn't fill with N "unidentified
|
||||
// brief speaker" entries.
|
||||
unknownClusters.add(i);
|
||||
}
|
||||
// else: large (>= 15s) + far-from-anchor → keep as own speaker.
|
||||
// Plausibly a real third+ person who's distinct from the main
|
||||
// anchors. Rare but possible.
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Build the final cluster-label ordering ──────────────────────
|
||||
// Order by first-appearance: whoever spoke first in the audio
|
||||
// gets Speaker_A. Anchors + kept-as-own clusters get labels;
|
||||
// reassigned + unknown clusters don't.
|
||||
const ordered = [];
|
||||
for (let i = 0; i < clusters.length; i++) {
|
||||
if (reassignTo.has(i) || unknownClusters.has(i)) continue;
|
||||
ordered.push({ idx: i, firstOrder: clusters[i].firstOrder });
|
||||
}
|
||||
ordered.sort((a, b) => a.firstOrder - b.firstOrder);
|
||||
const labelByOrigIdx = new Map();
|
||||
for (let j = 0; j < ordered.length; j++) {
|
||||
labelByOrigIdx.set(ordered[j].idx, globalSpeakerLabel(j));
|
||||
}
|
||||
// Reassigned clusters inherit their anchor's label
|
||||
for (const [i, ai] of reassignTo) {
|
||||
const anchorLabel = labelByOrigIdx.get(ai);
|
||||
if (anchorLabel) labelByOrigIdx.set(i, anchorLabel);
|
||||
}
|
||||
|
||||
// ─── Build globalMap + uncertaintyMap ────────────────────────────
|
||||
const globalMap = new Map();
|
||||
const uncertaintyMap = new Map();
|
||||
let hasUnknown = false;
|
||||
for (let i = 0; i < clusters.length; i++) {
|
||||
if (unknownClusters.has(i)) {
|
||||
for (const memberKey of clusters[i].members) {
|
||||
globalMap.set(memberKey, "Speaker_Unknown");
|
||||
hasUnknown = true;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
const label = labelByOrigIdx.get(i);
|
||||
if (!label) continue;
|
||||
const isReassigned = reassignTo.has(i);
|
||||
for (const memberKey of clusters[i].members) {
|
||||
globalMap.set(memberKey, label);
|
||||
if (isReassigned) uncertaintyMap.set(memberKey, true);
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Build the per-speaker summary ───────────────────────────────
|
||||
const speakers = {};
|
||||
const seenLabels = new Set([...labelByOrigIdx.values()]);
|
||||
for (const label of seenLabels) {
|
||||
speakers[label] = {
|
||||
turns: 0,
|
||||
total_speaking_seconds: 0,
|
||||
mean_confidence: null,
|
||||
chunks_appeared_in: 0,
|
||||
fingerprint_count: 0,
|
||||
};
|
||||
}
|
||||
if (hasUnknown) {
|
||||
speakers["Speaker_Unknown"] = {
|
||||
turns: 0,
|
||||
total_speaking_seconds: 0,
|
||||
mean_confidence: null,
|
||||
chunks_appeared_in: 0,
|
||||
fingerprint_count: 0,
|
||||
};
|
||||
}
|
||||
// Accumulate fingerprint counts from clusters that contributed to
|
||||
// each label. Reassigned clusters' fingerprints count toward
|
||||
// their anchor's total.
|
||||
for (let i = 0; i < clusters.length; i++) {
|
||||
let targetLabel;
|
||||
if (unknownClusters.has(i)) targetLabel = "Speaker_Unknown";
|
||||
else targetLabel = labelByOrigIdx.get(i);
|
||||
if (!targetLabel || !speakers[targetLabel]) continue;
|
||||
speakers[targetLabel].fingerprint_count += clusters[i].members.length;
|
||||
}
|
||||
|
||||
// Accumulate turns / speaking time / confidence by walking
|
||||
// diarization segments through the globalMap.
|
||||
//
|
||||
// Two earlier bugs fixed here:
|
||||
//
|
||||
// 1. UNFINGERPRINTED SEGMENTS WERE SILENTLY DROPPED. The cluster-
|
||||
// index lookup only contains entries that have fingerprints —
|
||||
// but Sortformer routinely emits diar segments for speakers
|
||||
// whose voice TitaNet didn't aggregate a fingerprint for (very
|
||||
// brief utterances, soft speech, overlapped speech). Those
|
||||
// segments produced globalId === undefined and were dropped,
|
||||
// so the "total speech detected" totals understated reality
|
||||
// dramatically. A 1.5-hour call could show as "34% speech
|
||||
// detected" when in reality 70%+ of the audio was speech that
|
||||
// Sortformer found but TitaNet couldn't fingerprint. Now: an
|
||||
// unmapped segment falls through to Speaker_Unknown so the
|
||||
// time still gets accounted for. (The chip on the per-line
|
||||
// transcript still shows "?" for those segments — they just
|
||||
// aren't claimed by a wrong cluster.)
|
||||
//
|
||||
// 2. CHUNK-OVERLAP DOUBLE-COUNTING. Transcribe segments are
|
||||
// deduped at the chunk overlap boundary (handled in
|
||||
// hardware.js), but diar segments are not. Until this fix the
|
||||
// same speech in a 30s overlap zone got counted toward TWO
|
||||
// chunks, inflating speaker totals. Dedup here using the
|
||||
// chunk's overlapBoundarySec when present.
|
||||
const confidenceSum = new Map();
|
||||
const confidenceCount = new Map();
|
||||
const chunksByLabel = new Map();
|
||||
|
||||
// Ensure Speaker_Unknown exists in speakers map before we attribute
|
||||
// any unmapped time to it — clusterSpeakers may have created it
|
||||
// already (via the unknownClusters path) or not (when no clusters
|
||||
// were suppressed). Either way, we want it as a destination bucket.
|
||||
if (!speakers["Speaker_Unknown"]) {
|
||||
speakers["Speaker_Unknown"] = {
|
||||
turns: 0,
|
||||
total_speaking_seconds: 0,
|
||||
mean_confidence: null,
|
||||
chunks_appeared_in: 0,
|
||||
fingerprint_count: 0,
|
||||
};
|
||||
hasUnknown = true;
|
||||
}
|
||||
|
||||
for (const d of chunkDiarization || []) {
|
||||
if (!d || !d.ok || !Array.isArray(d.segments)) continue;
|
||||
// Chunk-overlap dedup: skip any segment whose GLOBAL start time
|
||||
// sits in the prior chunk's tail (which this chunk overlapped).
|
||||
// chunkOverlapBoundary is the global timestamp BEFORE which
|
||||
// segments in this chunk are duplicates of the prior chunk's
|
||||
// tail. Comes from the chunk planner (audio-meta.js) and is
|
||||
// 0 for chunk 0 (no prior chunk → no dedup).
|
||||
const chunkOverlapBoundary =
|
||||
typeof d.chunkOverlapBoundarySec === "number"
|
||||
? d.chunkOverlapBoundarySec
|
||||
: 0;
|
||||
const labelsInThisChunk = new Set();
|
||||
for (const seg of d.segments) {
|
||||
if ((seg.start || 0) < chunkOverlapBoundary) continue;
|
||||
let globalId = globalMap.get(`${d.chunkIndex}:${seg.speaker_local}`);
|
||||
// Unmapped (no fingerprint produced for this speaker_local in
|
||||
// this chunk) → bucket into Speaker_Unknown rather than drop.
|
||||
if (!globalId || !speakers[globalId]) {
|
||||
globalId = "Speaker_Unknown";
|
||||
}
|
||||
speakers[globalId].turns += 1;
|
||||
const segDuration = Math.max(0, (seg.end || 0) - (seg.start || 0));
|
||||
speakers[globalId].total_speaking_seconds += segDuration;
|
||||
if (typeof seg.confidence === "number" && Number.isFinite(seg.confidence)) {
|
||||
confidenceSum.set(globalId, (confidenceSum.get(globalId) || 0) + seg.confidence);
|
||||
confidenceCount.set(globalId, (confidenceCount.get(globalId) || 0) + 1);
|
||||
}
|
||||
labelsInThisChunk.add(globalId);
|
||||
}
|
||||
for (const label of labelsInThisChunk) {
|
||||
if (!chunksByLabel.has(label)) chunksByLabel.set(label, new Set());
|
||||
chunksByLabel.get(label).add(d.chunkIndex);
|
||||
}
|
||||
}
|
||||
|
||||
// If Speaker_Unknown ended up with zero turns (no unmapped + no
|
||||
// suppressed clusters contributed), drop it from the legend so we
|
||||
// don't show "? Unknown 0:00" by default.
|
||||
if (speakers["Speaker_Unknown"] && speakers["Speaker_Unknown"].turns === 0) {
|
||||
delete speakers["Speaker_Unknown"];
|
||||
hasUnknown = false;
|
||||
}
|
||||
for (const label of Object.keys(speakers)) {
|
||||
if (confidenceCount.get(label)) {
|
||||
speakers[label].mean_confidence =
|
||||
confidenceSum.get(label) / confidenceCount.get(label);
|
||||
}
|
||||
speakers[label].chunks_appeared_in = (chunksByLabel.get(label) || new Set()).size;
|
||||
speakers[label].total_speaking_seconds =
|
||||
Math.round(speakers[label].total_speaking_seconds * 10) / 10;
|
||||
}
|
||||
|
||||
// Logging: surface the suppression summary so operators can see
|
||||
// what happened ("14 clusters → 2 anchors + 12 small/uncertain
|
||||
// suppressed").
|
||||
const reassignedCount = reassignTo.size;
|
||||
const unknownClusterCount = unknownClusters.size;
|
||||
const finalCount =
|
||||
Object.keys(speakers).length - (hasUnknown ? 1 : 0);
|
||||
console.log(
|
||||
`[clustering] ${clusters.length} raw clusters → ${finalCount} primary + ` +
|
||||
`${reassignedCount} reassigned (uncertain) + ${unknownClusterCount} unknown ` +
|
||||
`(anchors >= ${anchorMinSec}s, uncertain margin ${uncertainMarginPct}%, ` +
|
||||
`unknown < ${smallMaxSec}s)`
|
||||
);
|
||||
|
||||
return {
|
||||
globalMap,
|
||||
uncertaintyMap,
|
||||
speakers,
|
||||
clusterCount: clusters.length,
|
||||
thresholdSimilarity: similarityThreshold,
|
||||
};
|
||||
}
|
||||
|
||||
// ─── Public: stamp global speaker labels onto transcript segments ───
|
||||
//
|
||||
// Walks the merged transcript segments and assigns each one a
|
||||
// `speaker` (global ID, e.g. "Speaker_A") + `speaker_confidence`
|
||||
// based on which diarization segment its midpoint falls inside.
|
||||
// When no diar segment covers the midpoint, we fall back to nearest-
|
||||
// midpoint matching with a 5-second window — beyond that, leave the
|
||||
// speaker null so the frontend can render as "(speaker unknown)" or
|
||||
// just drop the label.
|
||||
//
|
||||
// Mutates the segments in-place (and also returns the array) so
|
||||
// callers don't have to remember which they got.
|
||||
export function assignSpeakersToSegments(segments, chunkDiarization, globalMap, uncertaintyMap = null) {
|
||||
if (!Array.isArray(segments) || segments.length === 0) return segments;
|
||||
if (!globalMap || globalMap.size === 0) {
|
||||
// Diarization didn't run / produced nothing — leave segments
|
||||
// alone. Caller can detect this state via speakers === {}.
|
||||
return segments;
|
||||
}
|
||||
// Flatten all per-chunk diar segments into one timeline annotated
|
||||
// with the global speaker label + the suppression-uncertainty
|
||||
// flag (set when a small cluster was reassigned to an anchor —
|
||||
// chip will show "?" so the user knows attribution is best-guess).
|
||||
const flatDiar = [];
|
||||
for (const d of chunkDiarization || []) {
|
||||
if (!d || !d.ok || !Array.isArray(d.segments)) continue;
|
||||
for (const seg of d.segments) {
|
||||
const memberKey = `${d.chunkIndex}:${seg.speaker_local}`;
|
||||
const globalId = globalMap.get(memberKey);
|
||||
if (!globalId) continue;
|
||||
const uncertain = uncertaintyMap ? !!uncertaintyMap.get(memberKey) : false;
|
||||
flatDiar.push({
|
||||
start: seg.start || 0,
|
||||
end: seg.end || 0,
|
||||
speaker: globalId,
|
||||
confidence: typeof seg.confidence === "number" ? seg.confidence : null,
|
||||
uncertain,
|
||||
});
|
||||
}
|
||||
}
|
||||
flatDiar.sort((a, b) => a.start - b.start);
|
||||
|
||||
const NEAREST_FALLBACK_WINDOW_SEC = 5;
|
||||
|
||||
for (const e of segments) {
|
||||
const mid = ((e.start || 0) + (e.end || 0)) / 2;
|
||||
// Find segments that contain the midpoint
|
||||
let containing = null;
|
||||
let containingMostOverlap = 0;
|
||||
for (const d of flatDiar) {
|
||||
if (d.start <= mid && mid <= d.end) {
|
||||
// Score by overlap with the entry to handle the rare case of
|
||||
// multiple diar segments straddling one transcript line
|
||||
// (chunk overlap zones, choppy speaker turns).
|
||||
const overlap =
|
||||
Math.min(d.end, e.end || 0) - Math.max(d.start, e.start || 0);
|
||||
if (overlap > containingMostOverlap) {
|
||||
containing = d;
|
||||
containingMostOverlap = overlap;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (containing) {
|
||||
e.speaker = containing.speaker;
|
||||
e.speaker_confidence = containing.confidence;
|
||||
e.speaker_uncertain = !!containing.uncertain;
|
||||
continue;
|
||||
}
|
||||
// Fall back to nearest by midpoint distance (within window)
|
||||
let nearest = null;
|
||||
let nearestDist = Infinity;
|
||||
for (const d of flatDiar) {
|
||||
const dMid = (d.start + d.end) / 2;
|
||||
const dist = Math.abs(dMid - mid);
|
||||
if (dist < nearestDist) {
|
||||
nearestDist = dist;
|
||||
nearest = d;
|
||||
}
|
||||
}
|
||||
if (nearest && nearestDist <= NEAREST_FALLBACK_WINDOW_SEC) {
|
||||
e.speaker = nearest.speaker;
|
||||
e.speaker_confidence = nearest.confidence;
|
||||
e.speaker_uncertain = !!nearest.uncertain;
|
||||
} else {
|
||||
e.speaker = null;
|
||||
e.speaker_confidence = null;
|
||||
e.speaker_uncertain = false;
|
||||
}
|
||||
}
|
||||
|
||||
return segments;
|
||||
}
|
||||
Reference in New Issue
Block a user