speaker-detector 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

speaker_detector/cli.py

@@ -21,20 +21,9 @@ def main():
     # ---- list-speakers ----
     subparsers.add_parser("list-speakers", help="List enrolled speakers")
 
-    # ---- export-model ----
-    model_parser = subparsers.add_parser("export-model", help="Export ECAPA model to ONNX")
-    model_parser.add_argument("--pt", required=True, help="Path to embedding_model.ckpt")
-    model_parser.add_argument("--out", default="speaker_embedding.onnx", help="Output ONNX file")
-
-    # ---- export-speaker-json ----
-    emb_parser = subparsers.add_parser("export-speaker-json", help="Convert enrolled .pt file to browser-friendly .json")
-    emb_parser.add_argument("--pt", required=True, help="Path to enrolled_speakers.pt")
-    emb_parser.add_argument("--out", default="speakers.json", help="Output .json file for browser")
-
-    # ---- combine ----
-    comb_parser = subparsers.add_parser("combine", help="Combine individual .pt files into enrolled_speakers.pt")
-    comb_parser.add_argument("--folder", required=True, help="Folder with individual .pt files")
-    comb_parser.add_argument("--out", required=True, help="Output .pt file path")
+    # ---- rebuild ----
+    rebuild_cmd = subparsers.add_parser("rebuild", help="Rebuild embeddings")
+    rebuild_cmd.add_argument("--name", help="Name of the speaker to rebuild (leave empty to rebuild all)", default=None)
 
     # ---- Parse arguments ----
     args = parser.parse_args()
@@ -46,10 +35,8 @@ def main():
         os.environ["PYTHONWARNINGS"] = "ignore"
 
     # ---- Import modules after filtering warnings ----
-    from .core import enroll_speaker, identify_speaker, list_speakers
-    from .export_model import export_model_to_onnx
-    from .export_embeddings import export_embeddings_to_json
-    from .combine import combine_embeddings_from_folder
+    from .core import enroll_speaker, identify_speaker, list_speakers, rebuild_embedding
+    from .utils.analyze import rebuild_all_embeddings
 
     # ---- Command Dispatch ----
     if args.command == "enroll":
@@ -69,14 +56,13 @@ def main():
         else:
             print("⚠️  No speakers enrolled yet.")
 
-    elif args.command == "export-model":
-        export_model_to_onnx(args.pt, args.out)
-
-    elif args.command == "export-speaker-json":
-        export_embeddings_to_json(args.pt, args.out)
-
-    elif args.command == "combine":
-        combine_embeddings_from_folder(args.folder, args.out)
+    elif args.command == "rebuild":
+        if args.name:
+            rebuild_embedding(args.name)
+            print(f"🔁 Rebuilt: {args.name}")
+        else:
+            rebuild_all_embeddings()
+            print("🔁 Rebuilt all embeddings.")
 
     else:
         parser.print_help()

speaker_detector/core.py

@@ -1,103 +1,116 @@
-from speechbrain.pretrained import SpeakerRecognition
+# core.py
+
 from pathlib import Path
-import torchaudio
 import torch
+import torchaudio
+from speechbrain.inference import SpeakerRecognition
 
-# Storage directories
+# ── DIRECTORIES ──────────────────────────────────────────────────────────────
 BASE_DIR = Path(__file__).resolve().parent.parent / "storage"
 SPEAKER_AUDIO_DIR = BASE_DIR / "speakers"
 EMBEDDINGS_DIR = BASE_DIR / "embeddings"
+NOISE_DIR = BASE_DIR / "background_noise"
 
-# Ensure they exist
 SPEAKER_AUDIO_DIR.mkdir(parents=True, exist_ok=True)
 EMBEDDINGS_DIR.mkdir(parents=True, exist_ok=True)
+NOISE_DIR.mkdir(parents=True, exist_ok=True)
 
-# Load model once
+# ── MODEL LOADING ────────────────────────────────────────────────────────────
 MODEL = SpeakerRecognition.from_hparams(
-    source="speechbrain/spkrec-ecapa-voxceleb", savedir="model"
+    source="speechbrain/spkrec-ecapa-voxceleb",
+    savedir="model"
 )
 
-def get_embedding(audio_path):
-    try:
-        signal, fs = torchaudio.load(audio_path)
-        if signal.numel() == 0:
-            raise ValueError(f"{audio_path} is empty.")
-        return MODEL.encode_batch(signal).squeeze().detach().cpu()
-    except Exception as e:
-        raise RuntimeError(f"Failed to embed {audio_path}: {e}")
-
-def enroll_speaker(audio_path, speaker_id):
+# ── EMBEDDING HELPERS ────────────────────────────────────────────────────────
+def get_embedding(audio_path: str) -> torch.Tensor:
+    signal, fs = torchaudio.load(audio_path)
+    if signal.numel() == 0:
+        raise ValueError(f"{audio_path} is empty.")
+    return MODEL.encode_batch(signal).squeeze().detach().cpu()
+
+def average_embeddings(paths: list[str]) -> torch.Tensor:
+    embeddings = [get_embedding(p) for p in paths]
+    return torch.stack(embeddings).mean(dim=0)
+
+# ── ENROLL / IMPROVE ─────────────────────────────────────────────────────────
+def enroll_speaker(audio_path: str, speaker_id: str) -> None:
     speaker_dir = SPEAKER_AUDIO_DIR / speaker_id
     speaker_dir.mkdir(parents=True, exist_ok=True)
 
-    # Save audio sample
     existing = list(speaker_dir.glob("*.wav"))
-    new_index = len(existing) + 1
-    dest_path = speaker_dir / f"{new_index}.wav"
+    dest_path = speaker_dir / f"{len(existing)+1}.wav"
 
-    waveform, sample_rate = torchaudio.load(audio_path)
+    waveform, sr = torchaudio.load(audio_path)
     if waveform.numel() == 0:
         raise ValueError("Cannot enroll empty audio file.")
+    torchaudio.save(str(dest_path), waveform, sr)
 
-    torchaudio.save(str(dest_path), waveform, sample_rate)
-    print(f"🎙 Saved {speaker_id}'s recording #{new_index} → {dest_path}")
-
-    # Save embedding
     emb = get_embedding(audio_path)
-    emb_path = EMBEDDINGS_DIR / f"{speaker_id}.pt"
-    torch.save(emb, emb_path)
-    print(f"🧠 Saved embedding for {speaker_id} → {emb_path}")
+    torch.save(emb, EMBEDDINGS_DIR / f"{speaker_id}.pt")
 
-def identify_speaker(audio_path, threshold=0.25):
+def rebuild_embedding(speaker_id: str) -> None:
+    speaker_dir = SPEAKER_AUDIO_DIR / speaker_id
+    wavs = list(speaker_dir.glob("*.wav"))
+    if not wavs:
+        raise RuntimeError(f"No recordings for {speaker_id}.")
+    emb = average_embeddings([str(w) for w in wavs])
+    torch.save(emb, EMBEDDINGS_DIR / f"{speaker_id}.pt")
+
+# ── BACKGROUND NOISE MODELING ────────────────────────────────────────────────
+def compute_background_embedding() -> None:
+    paths = [str(p) for p in NOISE_DIR.glob("*.wav")]
+    if not paths:
+        raise RuntimeError("No background noise samples.")
+    emb = average_embeddings(paths)
+    torch.save(emb, EMBEDDINGS_DIR / "background_noise.pt")
+
+# ── IDENTIFICATION ───────────────────────────────────────────────────────────
+def identify_speaker(audio_path: str, threshold: float = 0.25) -> tuple[str, float]:
     try:
         test_emb = get_embedding(audio_path)
-    except Exception as e:
-        return {"speaker": "error", "score": 0, "error": str(e)}
+    except Exception:
+        return "error", 0.0
 
     scores = {}
     for emb_path in EMBEDDINGS_DIR.glob("*.pt"):
-        speaker_name = emb_path.stem
+        name = emb_path.stem
         try:
-            enrolled_emb = torch.load(emb_path)
-            score = torch.nn.functional.cosine_similarity(enrolled_emb, test_emb, dim=0).item()
-            scores[speaker_name] = score
-        except Exception as e:
+            emb = torch.load(emb_path)
+            score = torch.nn.functional.cosine_similarity(emb, test_emb, dim=0).item()
+            scores[name] = score
+        except:
             continue
 
     if not scores:
-        return {"speaker": "unknown", "score": 0}
+        return "unknown", 0.0
 
     sorted_scores = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)
-    best, second = sorted_scores[0], sorted_scores[1] if len(sorted_scores) > 1 else (None, None)
-    auto_thresh = best[1] - (second[1] if second else 0) > 0.1
-    is_match = auto_thresh or best[1] >= threshold
-
-    result = {
-        "speaker": best[0] if is_match else "unknown",
-        "score": round(best[1], 3),
-        "all_scores": {k: round(v, 3) for k, v in sorted_scores}
-    }
-    return result
-
-def list_speakers():
-    speakers = []
-    for dir in SPEAKER_AUDIO_DIR.iterdir():
-        if dir.is_dir():
-            count = len(list(dir.glob("*.wav")))
-            speakers.append(f"{dir.name} ({count} recording{'s' if count != 1 else ''})")
-    print(f"📋 Found {len(speakers)} enrolled speaker(s): {speakers}")
-    return [s.split()[0] for s in speakers]
-
-def rebuild_embedding(speaker_id):
-    speaker_dir = SPEAKER_AUDIO_DIR / speaker_id
-    wavs = list(speaker_dir.glob("*.wav"))
+    best, best_score = sorted_scores[0]
+    second_score = sorted_scores[1][1] if len(sorted_scores) > 1 else 0.0
+    auto_thresh = (best_score - second_score) > 0.1
+    match = auto_thresh or best_score >= threshold
 
-    if not wavs:
-        raise RuntimeError(f"No recordings found for {speaker_id}.")
+    return (best, round(best_score, 3)) if match else ("unknown", round(best_score, 3))
 
-    embeddings = [get_embedding(w) for w in wavs]
-    avg_emb = torch.stack(embeddings).mean(dim=0)
+# ── REBUILD CHECKING ─────────────────────────────────────────────────────────
+def list_speakers() -> list[str]:
+    return [p.name for p in SPEAKER_AUDIO_DIR.iterdir() if p.is_dir()]
 
+def speaker_needs_rebuild(speaker_id: str) -> bool:
+    speaker_dir = SPEAKER_AUDIO_DIR / speaker_id
     emb_path = EMBEDDINGS_DIR / f"{speaker_id}.pt"
-    torch.save(avg_emb, emb_path)
-    print(f"🔁 Rebuilt embedding for {speaker_id}")
+    if not emb_path.exists():
+        return True
+    emb_mtime = emb_path.stat().st_mtime
+    for wav in speaker_dir.glob("*.wav"):
+        if wav.stat().st_mtime > emb_mtime:
+            return True
+    return False
+
+def get_speakers_needing_rebuild() -> list[str]:
+    return [s for s in list_speakers() if speaker_needs_rebuild(s)]
+
+
+
+# ── ALIAS FOR COMPATIBILITY ──────────────────────────────────────────────────
+rebuild_embeddings_for_speaker = rebuild_embedding

speaker_detector/model/hyperparams.yaml

@@ -0,0 +1,58 @@
+# ############################################################################
+# Model: ECAPA big for Speaker verification
+# ############################################################################
+
+# Feature parameters
+n_mels: 80
+
+# Pretrain folder (HuggingFace)
+pretrained_path: speechbrain/spkrec-ecapa-voxceleb
+
+# Output parameters
+out_n_neurons: 7205
+
+# Model params
+compute_features: !new:speechbrain.lobes.features.Fbank
+    n_mels: !ref <n_mels>
+
+mean_var_norm: !new:speechbrain.processing.features.InputNormalization
+    norm_type: sentence
+    std_norm: False
+
+embedding_model: !new:speechbrain.lobes.models.ECAPA_TDNN.ECAPA_TDNN
+    input_size: !ref <n_mels>
+    channels: [1024, 1024, 1024, 1024, 3072]
+    kernel_sizes: [5, 3, 3, 3, 1]
+    dilations: [1, 2, 3, 4, 1]
+    attention_channels: 128
+    lin_neurons: 192
+
+classifier: !new:speechbrain.lobes.models.ECAPA_TDNN.Classifier
+    input_size: 192
+    out_neurons: !ref <out_n_neurons>
+
+mean_var_norm_emb: !new:speechbrain.processing.features.InputNormalization
+    norm_type: global
+    std_norm: False
+
+modules:
+    compute_features: !ref <compute_features>
+    mean_var_norm: !ref <mean_var_norm>
+    embedding_model: !ref <embedding_model>
+    mean_var_norm_emb: !ref <mean_var_norm_emb>
+    classifier: !ref <classifier>
+        
+label_encoder: !new:speechbrain.dataio.encoder.CategoricalEncoder
+
+        
+pretrainer: !new:speechbrain.utils.parameter_transfer.Pretrainer
+    loadables:
+        embedding_model: !ref <embedding_model>
+        mean_var_norm_emb: !ref <mean_var_norm_emb>
+        classifier: !ref <classifier>
+        label_encoder: !ref <label_encoder>
+    paths:
+        embedding_model: !ref <pretrained_path>/embedding_model.ckpt
+        mean_var_norm_emb: !ref <pretrained_path>/mean_var_norm_emb.ckpt
+        classifier: !ref <pretrained_path>/classifier.ckpt
+        label_encoder: !ref <pretrained_path>/label_encoder.txt