Function assign_labels

bindsnet/evaluation/evaluation.py:8–71

Assign labels to the neurons based on highest average spiking activity. :param spikes: Binary tensor of shape ``(n_samples, time, n_neurons)`` of a single layer's spiking activity. :param labels: Vector of shape ``(n_samples,)`` with data labels corresponding to spiking

(
    spikes: torch.Tensor,
    labels: torch.Tensor,
    n_labels: int,
    rates: Optional[torch.Tensor] = None,
    alpha: float = 1.0,
)

def assign_labels(
    spikes: torch.Tensor,
    labels: torch.Tensor,
    n_labels: int,
    rates: Optional[torch.Tensor] = None,
    alpha: float = 1.0,
) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
    # language=rst
    """
    Assign labels to the neurons based on highest average spiking activity.

    :param spikes: Binary tensor of shape ``(n_samples, time, n_neurons)`` of a single
        layer's spiking activity.
    :param labels: Vector of shape ``(n_samples,)`` with data labels corresponding to
        spiking activity.
    :param n_labels: The number of target labels in the data.
    :param rates: If passed, these represent spike rates from a previous
        ``assign_labels()`` call.
    :param alpha: Rate of decay of label assignments.
    :return: Tuple of class assignments, per-class spike proportions, and per-class
        firing rates. Neurons that never fired are assigned ``-1`` (unassigned) so
        they do not bias predictions toward class ``0``.
    """

    n_neurons = spikes.size(2)

    if rates is None:
        rates = torch.zeros((n_neurons, n_labels), device=spikes.device)

    # Sum over time dimension (spike ordering doesn't matter).
    spikes = spikes.sum(1)

    for i in range(n_labels):
        # Create mask.
        mask = labels == i
        # Count the number of samples with this label.
        n_labeled = mask.sum().float()

        if n_labeled > 0:
            # Get indices of samples with this label.
            label_sum = spikes[mask].sum(0)
            # Update rates.
            rates[:, i] = alpha * rates[:, i] + (label_sum / n_labeled)

    # Compute proportions of spike activity per class.
    total_activity = rates.sum(1, keepdim=True)
    proportions = torch.where(
        total_activity > 0, rates / total_activity, torch.zeros_like(rates)
    )

    # Noise for random tie breaking.
    eps = 1e-6  # Small enough not to distort real decisions
    noise = eps * torch.randn_like(proportions)

    # Neuron assignments are the labels they fire most for.
    assignments = torch.argmax(proportions + noise, dim=1)

    # Neurons that never fired have no class preference; mark them with -1 so