speaker-detector 0.1.3__py3-none-any.whl

speaker_detector/ECAPA_TDNN.py

@@ -0,0 +1,633 @@
+"""A popular speaker recognition and diarization model.
+
+Authors
+ * Hwidong Na 2020
+"""
+
+import torch  # noqa: F401
+import torch.nn as nn
+import torch.nn.functional as F
+
+from speechbrain.dataio.dataio import length_to_mask
+from speechbrain.nnet.CNN import Conv1d as _Conv1d
+from speechbrain.nnet.linear import Linear
+from speechbrain.nnet.normalization import BatchNorm1d as _BatchNorm1d
+
+
+# Skip transpose as much as possible for efficiency
+class Conv1d(_Conv1d):
+    """1D convolution. Skip transpose is used to improve efficiency."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(skip_transpose=True, *args, **kwargs)
+
+
+class BatchNorm1d(_BatchNorm1d):
+    """1D batch normalization. Skip transpose is used to improve efficiency."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(skip_transpose=True, *args, **kwargs)
+
+
+class TDNNBlock(nn.Module):
+    """An implementation of TDNN.
+
+    Arguments
+    ---------
+    in_channels : int
+        Number of input channels.
+    out_channels : int
+        The number of output channels.
+    kernel_size : int
+        The kernel size of the TDNN blocks.
+    dilation : int
+        The dilation of the TDNN block.
+    activation : torch class
+        A class for constructing the activation layers.
+    groups : int
+        The groups size of the TDNN blocks.
+    dropout : float
+        Rate of channel dropout during training.
+
+    Example
+    -------
+    >>> inp_tensor = torch.rand([8, 120, 64]).transpose(1, 2)
+    >>> layer = TDNNBlock(64, 64, kernel_size=3, dilation=1)
+    >>> out_tensor = layer(inp_tensor).transpose(1, 2)
+    >>> out_tensor.shape
+    torch.Size([8, 120, 64])
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        kernel_size,
+        dilation,
+        activation=nn.ReLU,
+        groups=1,
+        dropout=0.0,
+    ):
+        super().__init__()
+        self.conv = Conv1d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            dilation=dilation,
+            groups=groups,
+        )
+        self.activation = activation()
+        self.norm = BatchNorm1d(input_size=out_channels)
+        self.dropout = nn.Dropout1d(p=dropout)
+
+    def forward(self, x):
+        """Processes the input tensor x and returns an output tensor."""
+        return self.dropout(self.norm(self.activation(self.conv(x))))
+
+
+class Res2NetBlock(torch.nn.Module):
+    """An implementation of Res2NetBlock w/ dilation.
+
+    Arguments
+    ---------
+    in_channels : int
+        The number of channels expected in the input.
+    out_channels : int
+        The number of output channels.
+    scale : int
+        The scale of the Res2Net block.
+    kernel_size: int
+        The kernel size of the Res2Net block.
+    dilation : int
+        The dilation of the Res2Net block.
+    dropout : float
+        Rate of channel dropout during training.
+
+    Example
+    -------
+    >>> inp_tensor = torch.rand([8, 120, 64]).transpose(1, 2)
+    >>> layer = Res2NetBlock(64, 64, scale=4, dilation=3)
+    >>> out_tensor = layer(inp_tensor).transpose(1, 2)
+    >>> out_tensor.shape
+    torch.Size([8, 120, 64])
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        scale=8,
+        kernel_size=3,
+        dilation=1,
+        dropout=0.0,
+    ):
+        super().__init__()
+        assert in_channels % scale == 0
+        assert out_channels % scale == 0
+
+        in_channel = in_channels // scale
+        hidden_channel = out_channels // scale
+
+        self.blocks = nn.ModuleList(
+            [
+                TDNNBlock(
+                    in_channel,
+                    hidden_channel,
+                    kernel_size=kernel_size,
+                    dilation=dilation,
+                    dropout=dropout,
+                )
+                for i in range(scale - 1)
+            ]
+        )
+        self.scale = scale
+
+    def forward(self, x):
+        """Processes the input tensor x and returns an output tensor."""
+        y = []
+        for i, x_i in enumerate(torch.chunk(x, self.scale, dim=1)):
+            if i == 0:
+                y_i = x_i
+            elif i == 1:
+                y_i = self.blocks[i - 1](x_i)
+            else:
+                y_i = self.blocks[i - 1](x_i + y_i)
+            y.append(y_i)
+        y = torch.cat(y, dim=1)
+        return y
+
+
+class SEBlock(nn.Module):
+    """An implementation of squeeze-and-excitation block.
+
+    Arguments
+    ---------
+    in_channels : int
+        The number of input channels.
+    se_channels : int
+        The number of output channels after squeeze.
+    out_channels : int
+        The number of output channels.
+
+    Example
+    -------
+    >>> inp_tensor = torch.rand([8, 120, 64]).transpose(1, 2)
+    >>> se_layer = SEBlock(64, 16, 64)
+    >>> lengths = torch.rand((8,))
+    >>> out_tensor = se_layer(inp_tensor, lengths).transpose(1, 2)
+    >>> out_tensor.shape
+    torch.Size([8, 120, 64])
+    """
+
+    def __init__(self, in_channels, se_channels, out_channels):
+        super().__init__()
+
+        self.conv1 = Conv1d(
+            in_channels=in_channels, out_channels=se_channels, kernel_size=1
+        )
+        self.relu = torch.nn.ReLU(inplace=True)
+        self.conv2 = Conv1d(
+            in_channels=se_channels, out_channels=out_channels, kernel_size=1
+        )
+        self.sigmoid = torch.nn.Sigmoid()
+
+    def forward(self, x, lengths=None):
+        """Processes the input tensor x and returns an output tensor."""
+        L = x.shape[-1]
+        if lengths is not None:
+            mask = length_to_mask(lengths * L, max_len=L, device=x.device)
+            mask = mask.unsqueeze(1)
+            total = mask.sum(dim=2, keepdim=True)
+            s = (x * mask).sum(dim=2, keepdim=True) / total
+        else:
+            s = x.mean(dim=2, keepdim=True)
+
+        s = self.relu(self.conv1(s))
+        s = self.sigmoid(self.conv2(s))
+
+        return s * x
+
+
+class AttentiveStatisticsPooling(nn.Module):
+    """This class implements an attentive statistic pooling layer for each channel.
+    It returns the concatenated mean and std of the input tensor.
+
+    Arguments
+    ---------
+    channels: int
+        The number of input channels.
+    attention_channels: int
+        The number of attention channels.
+    global_context: bool
+        Whether to use global context.
+
+    Example
+    -------
+    >>> inp_tensor = torch.rand([8, 120, 64]).transpose(1, 2)
+    >>> asp_layer = AttentiveStatisticsPooling(64)
+    >>> lengths = torch.rand((8,))
+    >>> out_tensor = asp_layer(inp_tensor, lengths).transpose(1, 2)
+    >>> out_tensor.shape
+    torch.Size([8, 1, 128])
+    """
+
+    def __init__(self, channels, attention_channels=128, global_context=True):
+        super().__init__()
+
+        self.eps = 1e-12
+        self.global_context = global_context
+        if global_context:
+            self.tdnn = TDNNBlock(channels * 3, attention_channels, 1, 1)
+        else:
+            self.tdnn = TDNNBlock(channels, attention_channels, 1, 1)
+        self.tanh = nn.Tanh()
+        self.conv = Conv1d(
+            in_channels=attention_channels, out_channels=channels, kernel_size=1
+        )
+
+    def forward(self, x, lengths=None):
+        """Calculates mean and std for a batch (input tensor).
+
+        Arguments
+        ---------
+        x : torch.Tensor
+            Tensor of shape [N, C, L].
+        lengths : torch.Tensor
+            The corresponding relative lengths of the inputs.
+
+        Returns
+        -------
+        pooled_stats : torch.Tensor
+            mean and std of batch
+        """
+        L = x.shape[-1]
+
+        def _compute_statistics(x, m, dim=2, eps=self.eps):
+            mean = (m * x).sum(dim)
+            std = torch.sqrt(
+                (m * (x - mean.unsqueeze(dim)).pow(2)).sum(dim).clamp(eps)
+            )
+            return mean, std
+
+        if lengths is None:
+            lengths = torch.ones(x.shape[0], device=x.device)
+
+        # Make binary mask of shape [N, 1, L]
+        mask = length_to_mask(lengths * L, max_len=L, device=x.device)
+        mask = mask.unsqueeze(1)
+
+        # Expand the temporal context of the pooling layer by allowing the
+        # self-attention to look at global properties of the utterance.
+        if self.global_context:
+            # torch.std is unstable for backward computation
+            # https://github.com/pytorch/pytorch/issues/4320
+            total = mask.sum(dim=2, keepdim=True).float()
+            mean, std = _compute_statistics(x, mask / total)
+            mean = mean.unsqueeze(2).repeat(1, 1, L)
+            std = std.unsqueeze(2).repeat(1, 1, L)
+            attn = torch.cat([x, mean, std], dim=1)
+        else:
+            attn = x
+
+        # Apply layers
+        attn = self.conv(self.tanh(self.tdnn(attn)))
+
+        # Filter out zero-paddings
+        attn = attn.masked_fill(mask == 0, float("-inf"))
+
+        attn = F.softmax(attn, dim=2)
+        mean, std = _compute_statistics(x, attn)
+        # Append mean and std of the batch
+        pooled_stats = torch.cat((mean, std), dim=1)
+        pooled_stats = pooled_stats.unsqueeze(2)
+
+        return pooled_stats
+
+
+class SERes2NetBlock(nn.Module):
+    """An implementation of building block in ECAPA-TDNN, i.e.,
+    TDNN-Res2Net-TDNN-SEBlock.
+
+    Arguments
+    ---------
+    in_channels: int
+        Expected size of input channels.
+    out_channels: int
+        The number of output channels.
+    res2net_scale: int
+        The scale of the Res2Net block.
+    se_channels : int
+        The number of output channels after squeeze.
+    kernel_size: int
+        The kernel size of the TDNN blocks.
+    dilation: int
+        The dilation of the Res2Net block.
+    activation : torch class
+        A class for constructing the activation layers.
+    groups: int
+        Number of blocked connections from input channels to output channels.
+    dropout: float
+        Rate of channel dropout during training.
+
+    Example
+    -------
+    >>> x = torch.rand(8, 120, 64).transpose(1, 2)
+    >>> conv = SERes2NetBlock(64, 64, res2net_scale=4)
+    >>> out = conv(x).transpose(1, 2)
+    >>> out.shape
+    torch.Size([8, 120, 64])
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        out_channels,
+        res2net_scale=8,
+        se_channels=128,
+        kernel_size=1,
+        dilation=1,
+        activation=torch.nn.ReLU,
+        groups=1,
+        dropout=0.0,
+    ):
+        super().__init__()
+        self.out_channels = out_channels
+        self.tdnn1 = TDNNBlock(
+            in_channels,
+            out_channels,
+            kernel_size=1,
+            dilation=1,
+            activation=activation,
+            groups=groups,
+            dropout=dropout,
+        )
+        self.res2net_block = Res2NetBlock(
+            out_channels, out_channels, res2net_scale, kernel_size, dilation
+        )
+        self.tdnn2 = TDNNBlock(
+            out_channels,
+            out_channels,
+            kernel_size=1,
+            dilation=1,
+            activation=activation,
+            groups=groups,
+            dropout=dropout,
+        )
+        self.se_block = SEBlock(out_channels, se_channels, out_channels)
+
+        self.shortcut = None
+        if in_channels != out_channels:
+            self.shortcut = Conv1d(
+                in_channels=in_channels,
+                out_channels=out_channels,
+                kernel_size=1,
+            )
+
+    def forward(self, x, lengths=None):
+        """Processes the input tensor x and returns an output tensor."""
+        residual = x
+        if self.shortcut:
+            residual = self.shortcut(x)
+
+        x = self.tdnn1(x)
+        x = self.res2net_block(x)
+        x = self.tdnn2(x)
+        x = self.se_block(x, lengths)
+
+        return x + residual
+
+
+class ECAPA_TDNN(torch.nn.Module):
+    """An implementation of the speaker embedding model in a paper.
+    "ECAPA-TDNN: Emphasized Channel Attention, Propagation and Aggregation in
+    TDNN Based Speaker Verification" (https://arxiv.org/abs/2005.07143).
+
+    Arguments
+    ---------
+    input_size : int
+        Expected size of the input dimension.
+    device : str
+        Device used, e.g., "cpu" or "cuda".
+    lin_neurons : int
+        Number of neurons in linear layers.
+    activation : torch class
+        A class for constructing the activation layers.
+    channels : list of ints
+        Output channels for TDNN/SERes2Net layer.
+    kernel_sizes : list of ints
+        List of kernel sizes for each layer.
+    dilations : list of ints
+        List of dilations for kernels in each layer.
+    attention_channels: int
+        The number of attention channels.
+    res2net_scale : int
+        The scale of the Res2Net block.
+    se_channels : int
+        The number of output channels after squeeze.
+    global_context: bool
+        Whether to use global context.
+    groups : list of ints
+        List of groups for kernels in each layer.
+    dropout : float
+        Rate of channel dropout during training.
+
+    Example
+    -------
+    >>> input_feats = torch.rand([5, 120, 80])
+    >>> compute_embedding = ECAPA_TDNN(80, lin_neurons=192)
+    >>> outputs = compute_embedding(input_feats)
+    >>> outputs.shape
+    torch.Size([5, 1, 192])
+    """
+
+    def __init__(
+        self,
+        input_size,
+        device="cpu",
+        lin_neurons=192,
+        activation=torch.nn.ReLU,
+        channels=[512, 512, 512, 512, 1536],
+        kernel_sizes=[5, 3, 3, 3, 1],
+        dilations=[1, 2, 3, 4, 1],
+        attention_channels=128,
+        res2net_scale=8,
+        se_channels=128,
+        global_context=True,
+        groups=[1, 1, 1, 1, 1],
+        dropout=0.0,
+    ):
+        super().__init__()
+        assert len(channels) == len(kernel_sizes)
+        assert len(channels) == len(dilations)
+        self.channels = channels
+        self.blocks = nn.ModuleList()
+
+        # The initial TDNN layer
+        self.blocks.append(
+            TDNNBlock(
+                input_size,
+                channels[0],
+                kernel_sizes[0],
+                dilations[0],
+                activation,
+                groups[0],
+                dropout,
+            )
+        )
+
+        # SE-Res2Net layers
+        for i in range(1, len(channels) - 1):
+            self.blocks.append(
+                SERes2NetBlock(
+                    channels[i - 1],
+                    channels[i],
+                    res2net_scale=res2net_scale,
+                    se_channels=se_channels,
+                    kernel_size=kernel_sizes[i],
+                    dilation=dilations[i],
+                    activation=activation,
+                    groups=groups[i],
+                    dropout=dropout,
+                )
+            )
+
+        # Multi-layer feature aggregation
+        self.mfa = TDNNBlock(
+            channels[-2] * (len(channels) - 2),
+            channels[-1],
+            kernel_sizes[-1],
+            dilations[-1],
+            activation,
+            groups=groups[-1],
+            dropout=dropout,
+        )
+
+        # Attentive Statistical Pooling
+        self.asp = AttentiveStatisticsPooling(
+            channels[-1],
+            attention_channels=attention_channels,
+            global_context=global_context,
+        )
+        self.asp_bn = BatchNorm1d(input_size=channels[-1] * 2)
+
+        # Final linear transformation
+        self.fc = Conv1d(
+            in_channels=channels[-1] * 2,
+            out_channels=lin_neurons,
+            kernel_size=1,
+        )
+
+    def forward(self, x, lengths=None):
+        """Returns the embedding vector.
+
+        Arguments
+        ---------
+        x : torch.Tensor
+            Tensor of shape (batch, time, channel).
+        lengths : torch.Tensor
+            Corresponding relative lengths of inputs.
+
+        Returns
+        -------
+        x : torch.Tensor
+            Embedding vector.
+        """
+        # Minimize transpose for efficiency
+        x = x.transpose(1, 2)
+
+        xl = []
+        for layer in self.blocks:
+            try:
+                x = layer(x, lengths=lengths)
+            except TypeError:
+                x = layer(x)
+            xl.append(x)
+
+        # Multi-layer feature aggregation
+        x = torch.cat(xl[1:], dim=1)
+        x = self.mfa(x)
+
+        # Attentive Statistical Pooling
+        x = self.asp(x, lengths=lengths)
+        x = self.asp_bn(x)
+
+        # Final linear transformation
+        x = self.fc(x)
+
+        x = x.transpose(1, 2)
+        return x
+
+
+class Classifier(torch.nn.Module):
+    """This class implements the cosine similarity on the top of features.
+
+    Arguments
+    ---------
+    input_size : int
+        Expected size of input dimension.
+    device : str
+        Device used, e.g., "cpu" or "cuda".
+    lin_blocks : int
+        Number of linear layers.
+    lin_neurons : int
+        Number of neurons in linear layers.
+    out_neurons : int
+        Number of classes.
+
+    Example
+    -------
+    >>> classify = Classifier(input_size=2, lin_neurons=2, out_neurons=2)
+    >>> outputs = torch.tensor([ [1., -1.], [-9., 1.], [0.9, 0.1], [0.1, 0.9] ])
+    >>> outputs = outputs.unsqueeze(1)
+    >>> cos = classify(outputs)
+    >>> (cos < -1.0).long().sum()
+    tensor(0)
+    >>> (cos > 1.0).long().sum()
+    tensor(0)
+    """
+
+    def __init__(
+        self,
+        input_size,
+        device="cpu",
+        lin_blocks=0,
+        lin_neurons=192,
+        out_neurons=1211,
+    ):
+        super().__init__()
+        self.blocks = nn.ModuleList()
+
+        for block_index in range(lin_blocks):
+            self.blocks.extend(
+                [
+                    _BatchNorm1d(input_size=input_size),
+                    Linear(input_size=input_size, n_neurons=lin_neurons),
+                ]
+            )
+            input_size = lin_neurons
+
+        # Final Layer
+        self.weight = nn.Parameter(
+            torch.FloatTensor(out_neurons, input_size, device=device)
+        )
+        nn.init.xavier_uniform_(self.weight)
+
+    def forward(self, x):
+        """Returns the output probabilities over speakers.
+
+        Arguments
+        ---------
+        x : torch.Tensor
+            Torch tensor.
+
+        Returns
+        -------
+        out : torch.Tensor
+            Output probabilities over speakers.
+        """
+        for layer in self.blocks:
+            x = layer(x)
+
+        # Need to be normalized
+        x = F.linear(F.normalize(x.squeeze(1)), F.normalize(self.weight))
+        return x.unsqueeze(1)

speaker_detector/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

speaker_detector/analyze.py

@@ -0,0 +1,59 @@
+from pathlib import Path
+import torchaudio
+import torch
+from speaker_detector.core import get_embedding, STORAGE_DIR
+
+CHUNK_DURATION = 2.5  # seconds
+
+def match_speaker(embedding, speaker_embeddings):
+    scores = {}
+    for name, emb in speaker_embeddings.items():
+        score = torch.nn.functional.cosine_similarity(emb, embedding, dim=0).item()
+        scores[name] = score
+    if not scores:
+        return "unknown", 0.0
+    best = max(scores.items(), key=lambda kv: kv[1])
+    return best[0], round(best[1], 3)
+
+def analyze_meeting(wav_path):
+    waveform, sample_rate = torchaudio.load(wav_path)
+    duration_sec = waveform.shape[1] / sample_rate
+
+    chunk_samples = int(CHUNK_DURATION * sample_rate)
+    num_chunks = int(waveform.shape[1] / chunk_samples)
+
+    # Load enrolled speaker embeddings
+    speaker_embeddings = {}
+    for spk_dir in STORAGE_DIR.iterdir():
+        if not spk_dir.is_dir():
+            continue
+        wavs = list(spk_dir.glob("*.wav"))
+        if not wavs:
+            continue
+        # Average multiple embeddings
+        embs = [get_embedding(str(wav)) for wav in wavs]
+        speaker_embeddings[spk_dir.name] = torch.stack(embs).mean(dim=0)
+
+    results = []
+
+    for i in range(num_chunks):
+        start_sample = i * chunk_samples
+        end_sample = start_sample + chunk_samples
+        chunk = waveform[:, start_sample:end_sample]
+
+        tmp_path = Path(wav_path).parent / f"tmp_chunk_{i}.wav"
+        torchaudio.save(str(tmp_path), chunk, sample_rate)
+
+        embedding = get_embedding(str(tmp_path))
+        speaker, score = match_speaker(embedding, speaker_embeddings)
+
+        results.append({
+            "start": round(i * CHUNK_DURATION, 2),
+            "end": round((i + 1) * CHUNK_DURATION, 2),
+            "speaker": speaker,
+            "score": score
+        })
+
+        tmp_path.unlink()  # clean up
+
+    return results

speaker_detector/cli.py

@@ -0,0 +1,82 @@
+import warnings
+import argparse
+import os
+
+def main():
+    parser = argparse.ArgumentParser(prog="speaker-detector", description="Speaker Detector CLI")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # ---- Global options ----
+    parser.add_argument("--verbose", action="store_true", help="Show detailed logs and warnings")
+
+    # ---- enroll ----
+    enroll_cmd = subparsers.add_parser("enroll", help="Enroll a speaker from a .wav file")
+    enroll_cmd.add_argument("speaker_id", help="Name/ID of the speaker")
+    enroll_cmd.add_argument("audio_path", help="Path to .wav file")
+
+    # ---- identify ----
+    identify_cmd = subparsers.add_parser("identify", help="Identify speaker from a .wav file")
+    identify_cmd.add_argument("audio_path", help="Path to .wav file")
+
+    # ---- 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")
+
+    # ---- Parse arguments ----
+    args = parser.parse_args()
+
+    # ---- Suppress warnings unless --verbose ----
+    if not args.verbose:
+        warnings.simplefilter("ignore", category=DeprecationWarning)
+        warnings.simplefilter("ignore", category=UserWarning)
+        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
+
+    # ---- Command Dispatch ----
+    if args.command == "enroll":
+        enroll_speaker(args.audio_path, args.speaker_id)
+        print(f"✅ Enrolled: {args.speaker_id}")
+
+    elif args.command == "identify":
+        result = identify_speaker(args.audio_path)
+        print(f"🕵️  Identified: {result['speaker']} (score: {result['score']})")
+
+    elif args.command == "list-speakers":
+        speakers = list_speakers()
+        if speakers:
+            print("📋 Enrolled Speakers:")
+            for s in speakers:
+                print(f"  • {s}")
+        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)
+
+    else:
+        parser.print_help()

speaker_detector/combine.py

@@ -0,0 +1,22 @@
+import torch
+import os
+
+def combine_embeddings_from_folder(folder_path, output_path):
+    speaker_data = {}
+
+    for fname in os.listdir(folder_path):
+        if fname.endswith(".pt"):
+            label = os.path.splitext(fname)[0]
+            fpath = os.path.join(folder_path, fname)
+            tensor = torch.load(fpath, map_location="cpu")
+            if not isinstance(tensor, torch.Tensor):
+                print(f"❌ Skipping {fname}: not a valid tensor")
+                continue
+            speaker_data[label] = tensor
+
+    if not speaker_data:
+        print("⚠️ No valid .pt files found.")
+        return
+
+    torch.save(speaker_data, output_path)
+    print(f"✅ Combined {len(speaker_data)} speakers into {output_path}")

speaker_detector/core.py

@@ -0,0 +1,103 @@
+from speechbrain.pretrained import SpeakerRecognition
+from pathlib import Path
+import torchaudio
+import torch
+
+# Storage directories
+BASE_DIR = Path(__file__).resolve().parent.parent / "storage"
+SPEAKER_AUDIO_DIR = BASE_DIR / "speakers"
+EMBEDDINGS_DIR = BASE_DIR / "embeddings"
+
+# Ensure they exist
+SPEAKER_AUDIO_DIR.mkdir(parents=True, exist_ok=True)
+EMBEDDINGS_DIR.mkdir(parents=True, exist_ok=True)
+
+# Load model once
+MODEL = SpeakerRecognition.from_hparams(
+    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):
+    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"
+
+    waveform, sample_rate = torchaudio.load(audio_path)
+    if waveform.numel() == 0:
+        raise ValueError("Cannot enroll empty audio file.")
+
+    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}")
+
+def identify_speaker(audio_path, threshold=0.25):
+    try:
+        test_emb = get_embedding(audio_path)
+    except Exception as e:
+        return {"speaker": "error", "score": 0, "error": str(e)}
+
+    scores = {}
+    for emb_path in EMBEDDINGS_DIR.glob("*.pt"):
+        speaker_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:
+            continue
+
+    if not scores:
+        return {"speaker": "unknown", "score": 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"))
+
+    if not wavs:
+        raise RuntimeError(f"No recordings found for {speaker_id}.")
+
+    embeddings = [get_embedding(w) for w in wavs]
+    avg_emb = torch.stack(embeddings).mean(dim=0)
+
+    emb_path = EMBEDDINGS_DIR / f"{speaker_id}.pt"
+    torch.save(avg_emb, emb_path)
+    print(f"🔁 Rebuilt embedding for {speaker_id}")

speaker_detector/export_embeddings.py

@@ -0,0 +1,41 @@
+import torch
+import json
+
+def export_embeddings_to_json(pt_path, json_path):
+    """
+    Converts a .pt file containing speaker embeddings into a
+    JSON file for use in the browser frontend.
+
+    Expected input format:
+        {
+            "lara": tensor([...]),
+            "guest": tensor([...]),
+            ...
+        }
+
+    Output format:
+        [
+            { "label": "lara", "vector": [...] },
+            { "label": "guest", "vector": [...] },
+            ...
+        ]
+    """
+    data = torch.load(pt_path, map_location="cpu")
+
+    if not isinstance(data, dict):
+        raise ValueError("Expected a dict of {label: tensor} in the .pt file")
+
+    converted = []
+    for label, tensor in data.items():
+        if not isinstance(tensor, torch.Tensor):
+            print(f"⚠️ Skipping {label}: not a tensor")
+            continue
+        converted.append({
+            "label": label,
+            "vector": tensor.tolist()
+        })
+
+    with open(json_path, "w") as f:
+        json.dump(converted, f, indent=2)
+
+    print(f"✅ Exported {len(converted)} speaker embeddings to {json_path}")

speaker_detector/export_model.py

@@ -0,0 +1,40 @@
+import torch
+from speechbrain.lobes.models.ECAPA_TDNN import ECAPA_TDNN
+from collections import OrderedDict
+
+def export_model_to_onnx(ckpt_path, out_path):
+    model = ECAPA_TDNN(
+        input_size=80,
+        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,
+    )
+
+    state_dict = torch.load(ckpt_path, map_location="cpu")
+
+    if "model" in state_dict:
+        state_dict = state_dict["model"]
+
+    new_state_dict = OrderedDict()
+    for k, v in state_dict.items():
+        if k.startswith("embedding_model."):
+            k = k[len("embedding_model."):]
+        new_state_dict[k] = v
+
+    model.load_state_dict(new_state_dict)
+    model.eval()
+
+    dummy_input = torch.randn(1, 200, 80)
+    torch.onnx.export(
+        model,
+        dummy_input,
+        out_path,
+        input_names=["features"],
+        output_names=["embedding"],
+        dynamic_axes={"features": {0: "batch", 1: "time"}},
+        opset_version=12,
+    )
+
+    print(f"✅ Exported ECAPA-TDNN to {out_path}")

speaker_detector/generate_summary.py

@@ -0,0 +1,110 @@
+import os
+import torch
+import torchaudio
+import requests
+from pathlib import Path
+from pydub import AudioSegment
+from dotenv import load_dotenv
+from speaker_detector.core import get_embedding, STORAGE_DIR
+
+load_dotenv()
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+CHUNK_DURATION = 8  # seconds
+SCORE_THRESHOLD = 0.6
+MIN_VALID_DURATION = 1.0  # seconds
+WHISPER_API_URL = "https://api.openai.com/v1/audio/transcriptions"
+
+def match_speaker(embedding, speaker_embeddings):
+    scores = {
+        name: torch.nn.functional.cosine_similarity(emb, embedding, dim=0).item()
+        for name, emb in speaker_embeddings.items()
+    }
+    if not scores:
+        return "unknown", 0.0
+    best = max(scores.items(), key=lambda kv: kv[1])
+    return best[0], round(best[1], 3)
+
+def transcribe_full_audio(wav_path: Path) -> str:
+    try:
+        with open(wav_path, "rb") as f:
+            response = requests.post(
+                WHISPER_API_URL,
+                headers={"Authorization": f"Bearer {OPENAI_API_KEY}"},
+                files={"file": (wav_path.name, f, "audio/wav")},
+                data={
+                    "model": "whisper-1",
+                    "response_format": "json",
+                    "temperature": 0.2,
+                    "language": "en",
+                    "prompt": "This is a meeting transcription.",
+                },
+                timeout=120
+            )
+        response.raise_for_status()
+        return response.json()["text"].strip()
+    except Exception as e:
+        print(f"❌ Whisper failed: {e}")
+        return ""
+
+def is_valid_audio(path):
+    try:
+        waveform, sample_rate = torchaudio.load(str(path))
+        duration_sec = waveform.shape[1] / sample_rate
+        return duration_sec >= MIN_VALID_DURATION
+    except Exception:
+        return False
+
+def generate_summary(meeting_dir: Path):
+    meeting_dir = meeting_dir.resolve()
+    chunk_files = sorted([
+        f for f in meeting_dir.iterdir()
+        if f.name.startswith("chunk_") and f.suffix == ".wav" and is_valid_audio(f)
+    ])
+
+    if not chunk_files:
+        return {"warning": "No valid .wav chunks found in meeting folder.", "segments": []}
+
+    # Merge all chunks into one file
+    combined = AudioSegment.empty()
+    for f in chunk_files:
+        combined += AudioSegment.from_wav(f)
+    merged_path = meeting_dir / "combined.wav"
+    combined.export(merged_path, format="wav")
+
+    # Get full transcript
+    full_text = transcribe_full_audio(merged_path)
+    print("🧠 Full transcript:", full_text)
+
+    # Load speaker embeddings
+    speaker_embeddings = {}
+    for spk_dir in STORAGE_DIR.iterdir():
+        if spk_dir.is_dir():
+            wavs = [w for w in spk_dir.glob("*.wav") if is_valid_audio(w)]
+            if wavs:
+                embs = [get_embedding(str(w)) for w in wavs]
+                speaker_embeddings[spk_dir.name] = torch.stack(embs).mean(dim=0)
+
+    segments = []
+    total = len(chunk_files)
+
+    for idx, chunk in enumerate(chunk_files):
+        try:
+            emb = get_embedding(chunk)
+            speaker, score = match_speaker(emb, speaker_embeddings)
+            segment_text = f"[chunk {idx+1}]"
+            segments.append({
+                "timestamp": idx * CHUNK_DURATION,
+                "speaker": speaker if score >= SCORE_THRESHOLD else "unknown",
+                "score": round(score, 3),
+                "text": segment_text,
+                "progress": round((idx + 1) / total * 100)
+            })
+        except Exception as e:
+            print(f"❌ Failed on {chunk.name}: {e}")
+
+    return {
+        "transcript": full_text,
+        "segments": segments if segments else [],
+        "warning": None if segments else "No speaker segments found."
+    }

speaker_detector-0.1.3.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: speaker-detector
+Version: 0.1.3
+Summary: A CLI tool for speaker enrollment and identification using SpeechBrain.
+Author-email: Lara Whybrow <lara.whybrow@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/P0llen/speaker-detector
+Project-URL: Repository, https://github.com/P0llen/speaker-detector
+Project-URL: Issues, https://github.com/P0llen/speaker-detector/issues
+Project-URL: Documentation, https://github.com/P0llen/speaker-detector#readme
+Keywords: speaker-recognition,speechbrain,voice,cli,ai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: torch
+Requires-Dist: torchaudio
+Requires-Dist: speechbrain
+Requires-Dist: onnx
+
+# speaker-detector 🎙️
+
+A lightweight CLI tool for speaker enrollment and voice identification, powered by [SpeechBrain](https://speechbrain.readthedocs.io/).
+
+## 🔧 Features
+
+
+- ✅ Enroll speakers from .wav audio
+- 🕵️ Identify speakers from audio samples
+- 🧠 ECAPA-TDNN embedding-based matching
+- 🎛️ Simple, fast command-line interface
+- 📁 Clean file storage in `~/.speaker-detector/`
+- 🔊 Optional `--verbose` mode for debugging
+
+
+## 📦 Installation
+
+Install from [TestPyPI](https://test.pypi.org/):
+
+```bash
+pip install --index-url https://test.pypi.org/simple/ speaker-detector
+```
+
+## 🚀 Usage
+
+## 🎙️ Enroll a speaker:
+
+```bash
+speaker-detector record --enroll Lara
+```
+
+## 🕵️ Identify a speaker:
+
+```bash
+speaker-detector record --test
+```
+## 📋 List enrolled speakers:
+
+```bash
+speaker-detector list
+```
+
+## 🗂️ Project Structure
+
+~/.speaker-detector/enrollments/	    Saved .pt voice embeddings
+~/.speaker-detector/recordings/	        CLI-recorded .wav audio files
+
+🧹 Clean vs Verbose Mode
+By default, warnings from speechbrain, torch, etc. are hidden for a clean CLI experience.
+To enable full logs & deprecation warnings:
+
+speaker-detector --verbose identify samples/test_sample.wav
+
+🛠 Requirements
+Python 3.8+
+torch
+speechbrain
+numpy
+soundfile
+onnxruntime
+
+| Step                              | Command                                                                                                             | When / Purpose                | Output                                   |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------- | ----------------------------- | ---------------------------------------- |
+| **1. Export ECAPA Model to ONNX** | `speaker-detector export-model --pt models/embedding_model.ckpt --out ecapa_model.onnx`                             | Run once unless model changes | `ecapa_model.onnx`                       |
+| **2. Enroll Speaker**             | `speaker-detector enroll <speaker_id> <audio_path>`<br>Example:<br>`speaker-detector enroll Lara samples/lara1.wav` | Run per new speaker           | Individual `.pt` files (e.g., `Lara.pt`) |
+| **3. Combine Embeddings**         | `speaker-detector combine --folder data/embeddings/ --out data/enrolled_speakers.pt`                                | After enrolling speakers      | `enrolled_speakers.pt`                   |
+| **4. Export Speakers to JSON**    | `speaker-detector export-speaker-json --pt data/enrolled_speakers.pt --out public/speakers.json`                    | For frontend use              | `speakers.json`                          |
+| **5. Identify Speaker**           | `speaker-detector identify samples/test_sample.wav`                                                                 | Identify speaker from audio   | Console output: name + score             |
+| **6. List Enrolled Speakers**     | `speaker-detector list-speakers`                                                                                    | Show all enrolled speakers    | Console output: list of IDs              |
+| **Verbose Mode (optional)**       | Add `--verbose` to any command:<br>`speaker-detector --verbose identify samples/test_sample.wav`                    | Show warnings, detailed logs  | Developer debug info                     |
+
+
+
+
+NB: When pushing to Github, do not include any .identifier files.

speaker_detector-0.1.3.dist-info/RECORD

@@ -0,0 +1,15 @@
+speaker_detector/ECAPA_TDNN.py,sha256=KB5T-ye4c9ZWgTgn_SMH-T_-qYSEHQJJtf3xHjsfNPk,19024
+speaker_detector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+speaker_detector/__main__.py,sha256=EClCwCzb6h6YBpt0hrnG4h0mlNhNePyg_xBNNSVm1os,65
+speaker_detector/analyze.py,sha256=sA8qyzczdHUbJw2_1JIbXn1WpiKC5dHLPRtPPoppJzY,1943
+speaker_detector/cli.py,sha256=TKci4o4Fru-3NqUkPDRQRvtis2niNEAh9sQWwE5t6Us,3521
+speaker_detector/combine.py,sha256=yCiqG6VMojz0CxSTPqjx0RrUban8oFIcKlA1zFMzaU4,761
+speaker_detector/core.py,sha256=lQNOcmZs2IJOqrNKlk1BeVQX6tzc7BSpeP5Gordff-E,3586
+speaker_detector/export_embeddings.py,sha256=OxNXadzEiMEJgpmCG6HHFncUX7DumFvTOys1R6UMUnw,1151
+speaker_detector/export_model.py,sha256=qVVT2wSCnsPA8pSAEEyIMkY7Kc8uAgepc03MxBMT3xU,1146
+speaker_detector/generate_summary.py,sha256=oTWEf2bxTCRIUl8L17-J64FyhRbCPnDjihFluEnBWc8,3726
+speaker_detector-0.1.3.dist-info/METADATA,sha256=ilNHpXunmGzuyDUxadMHolzhHX2aNjsOBWZe8mHDgQc,4564
+speaker_detector-0.1.3.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+speaker_detector-0.1.3.dist-info/entry_points.txt,sha256=2B30ee2cTyeeA49x_TBURl53bDRiLWGK3NWhb9rlK3s,63
+speaker_detector-0.1.3.dist-info/top_level.txt,sha256=PJ5rfvd3GAbzMbc7-Fwhtufjf6HxzzTiiHociOy7RiM,17
+speaker_detector-0.1.3.dist-info/RECORD,,

speaker_detector-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.7.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

speaker_detector-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+speaker-detector = speaker_detector.cli:main

speaker_detector-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+speaker_detector